1、為什么學習Python？

人生苦短....哈哈,自己想吧?。?！

2、通過什么途徑學習的Python？

官網(wǎng)、網(wǎng)上視頻、學習網(wǎng)站

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

1、python代碼，簡介，明確，優(yōu)雅，簡單易懂

2、開發(fā)效率高

3、可擴展性強

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

解釋型：在執(zhí)行程序時，計算機才一條一條的將代碼解釋成機器語言給計算機來執(zhí)行

編譯型：是把源程序的每一條語句都編譯成機器語言，并保存成二進制文件，這樣計算機運行該程序時可以直接以機器語言來運行此程序，運行速度很快。

5、Python解釋器種類以及特點？

Cpython，IPython，Jpython，pypy，Ironpython

Python是一門解釋器語言，代碼想運行，必須通過解釋器執(zhí)行，Python存在多種解釋器，分別基于不同語言開發(fā)，每個解釋器有不同的特點，但都能正常運行Python代碼，以下是常用的五種Python解釋器：

CPython：當 從Python官方網(wǎng)站下載并安裝好Python2.7后，就直接獲得了一個官方版本的解 釋器：Cpython，這個解釋器是用C語言開發(fā)的，所以叫 CPython，在命名行下運行python， 就是啟動CPython解釋器，CPython是使用最廣的Python解釋器。 IPython：IPython是基于CPython之上的一個交互式解釋器，也就是說，IPython只是在交互方 式上有所增強，但是執(zhí)行Python代碼的功能和CPython是完全一樣的，好比很多國產(chǎn)瀏覽器 雖然外觀不同，但內(nèi)核其實是調(diào)用了IE。 PyPy：PyPy是另一個Python解釋器，它的目標是執(zhí)行速度，PyPy采用JIT技術(shù)， 對Python代進行動態(tài)編譯，所以可以顯著提高 Python代碼的執(zhí)行速度。 Jython：Jython是運行在Java平臺上的Python解釋器，可以直接把Python代碼編譯成Java字節(jié)碼執(zhí)行。 IronPython：IronPython和Jython類似，只不過IronPython是運行在微軟.Net平臺上的Python解釋器， 可以直接把Python代碼編譯成.Net的字節(jié)碼。 在Python的解釋器中，使用廣泛的是CPython，對于Python的編譯，除了可以采用以上解釋器 進行編譯外，技術(shù)高超的開發(fā)者還可以按照自己的需求自行編寫Python解釋器來執(zhí)行Python代碼，十分的方便！

6、位和字節(jié)的關(guān)系？

一個字節(jié)=8位

7、b、B、KB、MB、GB 的關(guān)系？

1B(字節(jié)) = 8b(位)

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

8、請至少列舉5個 PEP8 規(guī)范

1、縮進：每一級4個縮進。連續(xù)跨行應(yīng)該使用圓括號或大括號或者使用懸掛縮進。 2、代碼長度約束 一行列數(shù)：PEP8 規(guī)定最大為79列，如果拼接url很容易超限 一個函數(shù)：不可以超過30行；直觀來講就是完整顯示一個函數(shù)一個屏幕就夠了，不需要上下拖動 一個類：不要超過200行代碼，不要超過10個方法 一個模塊：不要超過500行 3、import 不要在一句import中引用多個庫 4、命名規(guī)范 5、注釋 總體原則，錯誤的注釋不如沒有注釋。所以當一段代碼發(fā)生變化時，第一件事就是要修改注釋！

9、通過代碼實現(xiàn)如下轉(zhuǎn)換：

答案： 二進制轉(zhuǎn)換成十進制：v = “0b1111011” print(int('0b1111011',2)) 十進制轉(zhuǎn)換成二進制：v = 18 print(bin(18)) 八進制轉(zhuǎn)換成十進制：v = “011” print(int('011',8)) 十進制轉(zhuǎn)換成八進制：v = 30 print(oct(30)) 十六進制轉(zhuǎn)換成十進制：v = “0x12” print(int('0x12',16)) 十進制轉(zhuǎn)換成十六進制：v = 87 print(hex(87))

10、請編寫一個函數(shù)實現(xiàn)將IP地址轉(zhuǎn)換成一個整數(shù)。

如 10.3.9.12 轉(zhuǎn)換規(guī)則為： 10 00001010 3 00000011 9 00001001 12 00001100 再將以上二進制拼接起來計算十進制結(jié)果：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遞歸的最大層數(shù)？

一般計算機默認的最大遞歸深度在1000左右，python最大遞歸深度一般在4000左右，跟計算 機的性能有關(guān)系，這個數(shù)不是一個定數(shù)，可通過一下方式測試 import sys print(sys.getrecursionlimit()) print(sys.setrecursionlimit(10000))

12、求結(jié)果：

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 區(qū)別？

ASCII碼：使用一個字節(jié)編碼，所以它的范圍基本是只有英文字母、數(shù)字和一些特殊符號 ，只有256個字符。

Unicode：能夠表示全世界所有的字節(jié)

GBK：是只用來編碼漢字的，GBK全稱《漢字內(nèi)碼擴展規(guī)范》，使用雙字節(jié)編碼。

UTF-8：是一種針對Unicode的可變長度字符編碼，又稱萬國碼。

14、字節(jié)碼和機器碼的區(qū)別？

機器碼：是電腦CPU直接讀取運行的機器指令，運行速度最快，但是非?；逎y懂

字節(jié)碼：是一種中間狀態(tài)（中間碼）的二進制代碼（文件）。需要直譯器轉(zhuǎn)譯后才能成為機器碼。

15、三元運算規(guī)則以及應(yīng)用場景？

規(guī)則：為真時的結(jié)果 if 判定條件 else 為假時的結(jié)果

```應(yīng)用場景：在賦值變量的時候，可以直接加判斷，然后賦值`

16、列舉 Python2和Python3的區(qū)別？

1、默認編碼：2-->ascii，3-->utf-8 2、print的區(qū)別：python2中print是一個語句，不論想輸出什么，直接放到print關(guān)鍵字后面即可。python3里，print()是一個函數(shù)， 像其他函數(shù)一樣，print()需要你將要輸出的東西作為參數(shù)傳給它。 3、input的區(qū)別： python2有兩個全局函數(shù)，用在命令行請求用戶輸入。第一個叫input()，它等待用戶輸入一個python表達式(然后返回結(jié)果)。 第二個叫做raw_input(),用戶輸入什么他就返回什么。python3 通過input替代了他們。 4、字符串：python2中有兩種字符串類型：Unicode字符串和非Unicode字符串。Python3中只有一種類型：Unicode字符串。 5、xrange() python２里，有兩種方法獲得一定范圍內(nèi)的數(shù)字：range(),返回一個列表，還有xrange(),返回一個迭代器。 python3　里，range()返回迭代器，xrange()不再存在。 更多不同：https://www.cnblogs.com/weikunzz/p/6857971.html

17、用一行代碼實現(xiàn)數(shù)值交換：

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

18、Python3和Python2中 int 和 long的區(qū)別？

python2有非浮點數(shù)準備的int和long類型。int類型最大值不能超過sys.maxint，而且這個最大值是平臺相關(guān)的。

可以通過在數(shù)字的末尾附上一個Ｌ來定義長整型，顯然，它比int類型表示的數(shù)字范圍更大。在python3里，

只有一種整數(shù)類型int,大多數(shù)情況下，和python２中的長整型類似。

19、xrange和range的區(qū)別？

python２里，有兩種方法獲得一定范圍內(nèi)的數(shù)字：range(),返回一個列表，還有xrange(),返回一個迭代器。

python3　里，range()返回迭代器，xrange()不再存在。

20、文件操作時：xreadlines和readlines的區(qū)別？

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表達式格式以及應(yīng)用場景？

表達式格式：lambda后面跟一個或多個參數(shù)，緊跟一個冒號，以后是一個表達式。冒號前是參數(shù)，冒號后是返回值。例如：lambda x : 2x

應(yīng)用場景：經(jīng)常與一些內(nèi)置函數(shù)相結(jié)合使用，比如說map(),filter(),sorted(),reduce()等

24、pass的作用？

1、空語句 do nothing

2、保證格式完整

3、保證語義完整

25、?arg和?*kwarg作用？

萬能參數(shù)，解決了函數(shù)參數(shù)不固定的問題

*arg：會把位置參數(shù)轉(zhuǎn)化為tuple

**kwarg：會把關(guān)鍵字參數(shù)轉(zhuǎn)化為dict

26、is和==的區(qū)別？

is:判斷內(nèi)存地址是否相等

==：判斷數(shù)值是否相等

27、簡述Python的深淺拷貝以及應(yīng)用場景？

copy()：淺copy，淺拷貝指僅僅拷貝數(shù)據(jù)集合的第一層數(shù)據(jù)

deepcopy():深copy,深拷貝指拷貝數(shù)據(jù)集合的所有層

28、Python垃圾回收機制？

python采用的是引用計數(shù)機制為主，標記-清除和分代收集(隔代回收、分代回收)兩種機制為輔的策略 計數(shù)機制 Python的GC模塊主要運用了引用計數(shù)來跟蹤和回收垃圾。在引用計數(shù)的基礎(chǔ)上，還可以通過“標記-清除” 解決容器對象可能產(chǎn)生的循環(huán)引用的問題。通過分代回收以空間換取時間進一步提高垃圾回收的效率。 標記-清除： 標記-清除的出現(xiàn)打破了循環(huán)引用，也就是它只關(guān)注那些可能會產(chǎn)生循環(huán)引用的對象 缺點：該機制所帶來的額外操作和需要回收的內(nèi)存塊成正比。 隔代回收 原理：將系統(tǒng)中的所有內(nèi)存塊根據(jù)其存活時間劃分為不同的集合，每一個集合就成為一個“代”， 垃圾收集的頻率隨著“代”的存活時間的增大而減小。也就是說，活得越長的對象，就越不可能是垃圾， 就應(yīng)該減少對它的垃圾收集頻率。那么如何來衡量這個存活時間：通常是利用幾次垃圾收集動作來衡量， 如果一個對象經(jīng)過的垃圾收集次數(shù)越多，可以得出：該對象存活時間就越長。

29、python的可變類型和不可變類型？

不可變類型（數(shù)字、字符串、元組、不可變集合）

可變類型（列表、字典、可變集合）

30、求結(jié)果：

v = dict.fromkeys(['k1','k2'],[]) v['k1'].append(666) print(v) v['k1'] = 777 print(v) 答案：{'k1':,'k2':} {'k1':777,'k2':} 解析：formkeys()默認參數(shù)為可變數(shù)據(jù)類型時有坑

31、求結(jié)果：

def num(): return [lambda x: i*x for i in range(4)] print([m(2) for m in num()]) 答案：[6, 6, 6, 6] 解析： 問題的本質(zhì)在與python中的屬性查找規(guī)則，LEGB（local，enclousing，global，bulitin）， 在上面的例子中，i就是在閉包作用域（enclousing），而Python的閉包是 遲綁定 ， 這意味著閉包中用到的變量的值，是在內(nèi)部函數(shù)被調(diào)用時查詢得到的 所以：[lambda x: i*x for i in range(4)]打印出來是含有四個內(nèi)存地址的列表，每個內(nèi)存地址中的i 在在本內(nèi)存中都沒有被定義，而是通過閉包作用域中的i值，當for循環(huán)執(zhí)行結(jié)束后，i的值等于3，所以 再執(zhí)行[m(2) for m in num()]時，每個內(nèi)存地址中的i值等于3，當x等于2時，打印出來的結(jié)果都是6， 從而得到結(jié)果[6, 6, 6, 6]。

32、列舉常見的內(nèi)置函數(shù)？

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)過濾函數(shù)

map(function，iterable)循環(huán)函數(shù)

reduce(function, iterable)累積函數(shù)

34、一行代碼實現(xiàn)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區(qū)別？

match:從字符串的開頭位置匹配，必須以此為開頭

search:從開頭開始查，找到符合的就返回結(jié)果

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

正則表達式一般趨向于最大長度匹配

39、求結(jié)果：

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) )===>返回一個生成器的內(nèi)存地址

40、求結(jié)果：

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) 函數(shù)的第二個默認參數(shù)是一個list，當?shù)谝淮螆?zhí)行的時候?qū)嵗艘粋€list， 第二次執(zhí)行還是用第一次執(zhí)行的時候?qū)嵗牡刂反鎯?，以后每次實例化都?/p>

42、如何實現(xiàn) "1,2,3" 變成 ['1','2','3'] ?

a = "1,2,3"

li = a.split(',')

43、如何實現(xiàn)[‘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,) ] 的區(qū)別？

a = [1,2,3]正常的列表

b = [(1),(2),(3)] 雖然列表的每個元素加上了括號，但是當括號內(nèi)只有一個元素并且沒有逗號時，其數(shù)據(jù)類型是元素本身的數(shù)據(jù)類型

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、一行代碼實現(xiàn)刪除列表中重復的值 ?

li = [1, 1, 1, 23, 3, 4, 4]

new_li = list(set(li))

new_li.sort(key=li.index)

47、如何在函數(shù)中設(shè)置一個全局變量 ?

使用python的內(nèi)置語法 globals 全局變量

48、logging模塊的作用？以及應(yīng)用場景？

logging模塊的作用：

1、程序調(diào)試

2、了解軟件程序運行情況，是否正常

3、軟件程序運行故障分析與問題定位

應(yīng)用場景：網(wǎng)站的運維工作，程序?qū)崟r監(jiān)控

49、請用代碼簡答實現(xiàn)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'內(nèi)容{變量名}')

51、簡述 生成器、迭代器、可迭代對象 以及應(yīng)用場景？

生成器：在 Python 中，一邊循環(huán)一邊計算的機制，稱為 生成器（generator）， 通過next()取值，兩種表現(xiàn)形式1、將列表生成式的[]改為()2、含有yield關(guān)鍵字的函數(shù) 應(yīng)用場景：優(yōu)化代碼，節(jié)省內(nèi)存 迭代器：是訪問集合元素的一種方式。迭代器同時實現(xiàn)了__iter__和__next__方法 可迭代對象：只要實現(xiàn)了__iter__方法的對象就是可迭代對象

52、用Python實現(xiàn)一個二分查找的函數(shù)。

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、談?wù)勀銓﹂]包的理解？

在一個外函數(shù)中定義了一個內(nèi)函數(shù)，內(nèi)函數(shù)里運用了外函數(shù)的臨時變量，并且外函數(shù)的返回值是內(nèi)函數(shù)的引用。這樣就構(gòu)成了一個閉包。

一般情況下，在我們認知當中，如果一個函數(shù)結(jié)束，函數(shù)的內(nèi)部所有東西都會釋放掉，還給內(nèi)存，局部變量都會消失。

但是閉包是一種特殊情況，如果外函數(shù)在結(jié)束的時候發(fā)現(xiàn)有自己的臨時變量將來會在內(nèi)部函數(shù)中用到，就把這個臨時變量綁定給了內(nèi)部函數(shù)，然后自己再結(jié)束。

54、os和sys模塊的作用？

os模塊負責程序與操作系統(tǒng)的交互，提供了訪問操作系統(tǒng)底層的接口;

sys模塊負責程序與python解釋器的交互，提供了一系列的函數(shù)和變量，用于操控python的運行時環(huán)境。

55、如何生成一個隨機數(shù)？

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、談?wù)勀銓γ嫦驅(qū)ο蟮睦斫猓?/span>

面向?qū)ο蟮某绦蛟O(shè)計的核心是對象（上帝式思維），要理解對象為何物，必須把自己當成上帝，上帝眼里世間存在的萬物皆為對象，

不存在的也可以創(chuàng)造出來。對象是特征和技能的結(jié)合，其中特征和技能分別對應(yīng)對象的數(shù)據(jù)屬性和方法屬性。

優(yōu)點是：解決了程序的擴展性。對某一個對象單獨修改，會立刻反映到整個體系中，如對游戲中一個人物參數(shù)的特征和技能修改都很容易。

缺點：可控性差，無法向面向過程的程序設(shè)計流水線式的可以很精準的預測問題的處理流程與結(jié)果，

面向?qū)ο蟮某绦蛞坏╅_始就由對象之間的交互解決問題，即便是上帝也無法預測最終結(jié)果。

應(yīng)用場景：需求經(jīng)常變化的軟件，一般需求的變化都集中在用戶層，互聯(lián)網(wǎng)應(yīng)用，企業(yè)內(nèi)部軟件，游戲等都是面向?qū)ο蟮某绦蛟O(shè)計大顯身手的好地方。

58、Python面向?qū)ο笾械睦^承有什么特點？

1：在繼承中基類的構(gòu)造(__init__()方法)不會被自動調(diào)用，它需要在其派生類的構(gòu)造中親自專門調(diào)用。 2：在調(diào)用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數(shù)變量。 區(qū)別于在類中調(diào)用普通函數(shù)時并不需要帶上self參數(shù) 3：Python總是首先查找對應(yīng)類型的方法，如果它不能在派生類中找到對應(yīng)的方法，它才開始到基類中逐個查找。 (先在本類中查找調(diào)用的方法，找不到才去基類中找)。

59、面向?qū)ο笊疃葍?yōu)先和廣度優(yōu)先是什么？

Python的類可以繼承多個類，那么其尋找類方法的方式有兩種： 當類是經(jīng)典類時(主要在python2版本中的沒有主動繼承object的類)，多繼承情況下，會按照深度優(yōu)先方式查找 當類是新式類時(python3版本中的所有類和python2中主動繼承object的類)，多繼承情況下，會按照廣度優(yōu)先方式查找 簡單點說就是：經(jīng)典類是縱向查找，新式類是橫向查找

60、面向?qū)ο笾衧uper的作用？

1、super在面向?qū)ο罄^承類中代指父類，書寫方法super(類名,self).屬性或者方法或super().屬性或者方法 2、super方法可以增加類之間調(diào)用的靈活性，當父類名發(fā)生變化時不必修改 3、super方法在類的多繼承時可以簡化代碼，避免代碼冗余 4、super機制里可以保證公共父類僅被執(zhí)行一次，執(zhí)行的順序遵循MRO，廣度優(yōu)先查詢方法

61、是否使用過functools中的函數(shù)？其作用是什么？

functools用于高階函數(shù)：指那些作用于函數(shù)或者返回其他函數(shù)的函數(shù)。通常情況下，只要是 可以被當做函數(shù)調(diào)用的對象就是這個模塊的目標。

62、列舉面向?qū)ο笾袔щp下劃線的特殊方法，如：?new?、?init

__new__：構(gòu)造方法，創(chuàng)建一個對象，實例化時第一個被執(zhí)行，返回一個創(chuàng)建好的對象及__init__(self)的self， 只有繼承了object的類才會有這個方法 __init__：初始化方法，__init__在__new__的基礎(chǔ)上完成一些其它初始化的動作，__init__沒有返回值

63、如何判斷是函數(shù)還是方法？

函數(shù)和方法都封裝了一些獨立的功能，如果在類中定義的函數(shù)那就是方法(對象或者類名點方法名調(diào)用)， 否則就是函數(shù)(函數(shù)名()直接調(diào)用)

64、靜態(tài)方法和類方法區(qū)別？

靜態(tài)方法：是既不是用類中的屬性又不使用對象中的屬性，由類或者對象調(diào)用的方法，依賴python裝飾器@staticmethod來實現(xiàn) 類方法：只使用類中的靜態(tài)變量，一般都是由類調(diào)用，依賴python裝飾器@classmethod來實現(xiàn)

65、列舉面向?qū)ο笾械奶厥獬蓡T以及應(yīng)用場景？

__call__：對象的構(gòu)造方法，對象加上()，可以觸發(fā)這個類的__call__方法。 __len__：內(nèi)置函數(shù)的len函數(shù)是依賴類中的__len__方法 __eq__：判斷值是否相等的時候依賴__eq__方法 __hash__:判斷hash值是否相等的時候依賴__hash__方法(拓展：set的去重機制其實就是根據(jù)__hash__和__eq__方法實現(xiàn)的) __str__：和str() print() %s 都是息息相關(guān)的，返回值一定是字符串類型 __repr__：和 repr() %r都是息息相關(guān)的，在沒有__str__方法時，__repr__可以完全取代__str__。 __del__ 析構(gòu)方法，對應(yīng)著一個對象的刪除之前執(zhí)行的內(nèi)容

66、1、2、3、4、5 能組成多少個互不相同且無重復的三位數(shù)

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、什么是反射？以及應(yīng)用場景？

定義：通過用字符串數(shù)據(jù)類型的變量名來訪問這個變量的值，在python面向?qū)ο笾械姆瓷?通過字符串的形式操作對象相關(guān)的屬性或方法. 應(yīng)用場景：用于處理通過用戶輸入，文件讀取，或者網(wǎng)絡(luò)傳輸所得到的字符串形式的指令來完成對應(yīng)的操作

68、metaclass作用？以及應(yīng)用場景？

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

69、用盡量多的方法實現(xiàn)單例模式。

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、基于模塊導入方式，現(xiàn)在一個py文件中寫好一個類，實例化一個對象。以后用這個類直接導入這個模塊就是單例模式。 3、基于裝飾器方法實現(xiàn) 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、裝飾器的寫法以及應(yīng)用場景。

裝飾器的寫法： def wrapper(func): def inner(*args,**kwargs): '被裝飾之前的操作' ret = func(*args,**kwargs) '被裝飾之后的操作' return ret return inner 裝飾器的應(yīng)用場景： 比如注冊登錄、插入日志，性能測試，事務(wù)處理，緩存等等場景

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

異常處理的常規(guī)寫法： try: 執(zhí)行的主體函數(shù) except Exception as e: print(str(e)) 主動拋出異常： raise TypeError('出現(xiàn)了不可思議的異常')#TypeError可以是任意的錯誤類型

72、什么是面向?qū)ο蟮膍ro

MRO(Method Resolution Order 方法解析順序)是面向?qū)ο笾杏糜诓樵冾惖亩嗬^承的繼承順序的方法， 它是基于算法來實現(xiàn)的，不同的算法實現(xiàn)的MRO的順序不同

73、isinstance作用以及應(yīng)用場景？

isinstance作用是來判斷一個對象是否是一個已知的類型

74、寫代碼并實現(xiàn)：

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] 代碼實現(xiàn) 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類型為數(shù)組類型，內(nèi)的元素需是整型，target也為整型，請檢查') else:return None

75、json序列化時，可以處理的數(shù)據(jù)類型有哪些？如何定制支持datetime類型？

1、可以處理的數(shù)據(jù)類型是 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序列化時，默認遇到中文會轉(zhuǎn)換成unicode，如果想要保留中文怎么辦？

在序列化是將json.dumps中的默認參數(shù)ensure_ascii改為False就可以保留中文了 json.dumps(obj,ensure_ascii=False)

77、什么是斷言？應(yīng)用場景？

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

78、使用代碼實現(xiàn)查看列舉目錄下的所有文件。

方法一：遞歸處理 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基礎(chǔ)' 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關(guān)鍵字。

yield 是一個類似 return 的關(guān)鍵字，只是這個函數(shù)返回的是個生成器當你調(diào)用這個函數(shù)的時候， 函數(shù)內(nèi)部的代碼并不立馬執(zhí)行 ，這個函數(shù)只是返回一個生成器對象，當你使用for進行迭代的時候， 函數(shù)中的代碼才會執(zhí)行 yield from 的主要功能是打開雙向通道，把最外層的調(diào)用方與最內(nèi)層的子生成器連接起來， 這樣二者可以直接發(fā)送和產(chǎn)出值，還可以直接傳入異常，而不用在位于中間的協(xié)程中添加大量處理異常的樣板代碼。 有了這個結(jié)構(gòu)，協(xié)程可以通過以前不可能的方式委托職責。 更多解析詳見：http://blog.gusibi.com/post/python-coroutine-yield-from/

80、代碼實現(xiàn)六位隨機驗證碼

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、代碼實現(xiàn)隨機發(fā)紅包功能

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)

小編給大家?guī)硪粋€福利，就是我給大家整理了一套全套的python的學習教程，今天無償分享給大家，這一套視頻是從華為的麒麟團隊極力推薦的一套python410集和學習電子書！

( ? ) 小驚喜：康康評論：獲取評論111