1、簡述編譯型和解釋型語言
編譯型：運(yùn)行前先由編譯器將高級語言代碼編譯為對應(yīng)機(jī)器的cpu匯編指令集，再由匯編器匯編為目標(biāo)機(jī)器碼，生成可執(zhí)行文件，然最后運(yùn)行生成的可執(zhí)行文件。最典型的代表語言為C/C++，一般生成的可執(zhí)行文件及.exe文件。

解釋型：在運(yùn)行時由翻譯器將高級語言代碼翻譯成易于執(zhí)行的中間代碼，并由解釋器（例如瀏覽器、虛擬機(jī)）逐一將該中間代碼解釋成機(jī)器碼并執(zhí)行（可看做是將編譯、運(yùn)行合二為一了）。最典型的代表語言為JavaScript、Python、Ruby和Perl等。 

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

在Python的解釋器中，使用廣泛的是CPython，對于Python的編譯，除了可以采用以上解釋器進(jìn)行編譯外，技術(shù)高超的開發(fā)者還可以按照自己的需求自行編寫Python解釋器來執(zhí)行Python代碼，十分的方便！

3、位和字節(jié)的關(guān)系
位(bit) ： 來自英文bit，表示二進(jìn)制位。位是計(jì)算機(jī)內(nèi)部數(shù)據(jù)儲存的最小單位，11010100是一個8位二進(jìn)制數(shù)。一個二進(jìn)制位只可以表示0和1兩種狀態(tài)；兩個二進(jìn)制位可以表示00、01、10、11四種狀態(tài)；三位二進(jìn)制數(shù)可表示八種狀態(tài)。

字節(jié)(byte)： 字節(jié)來自英文Byte，習(xí)慣上用大寫的“B”表示。

字節(jié)是計(jì)算機(jī)中數(shù)據(jù)處理的基本單位。計(jì)算機(jī)中以字節(jié)為單位存儲和解釋信息，規(guī)定一個字節(jié)由八個二進(jìn)制位構(gòu)成，即1個字節(jié)等于8個比特（1Byte=8bit）。八位二進(jìn)制數(shù)最小為00000000，最大為11111111；通常1個字節(jié)可以存入一個ASCII碼，2個字節(jié)可以存放一個漢字國標(biāo)碼。

4、至少舉例5個pep8規(guī)范
縮進(jìn)/空格/注釋/命名等
http://blog.sae.sina.com.cn/archives/4781

5、通過代碼實(shí)現(xiàn)進(jìn)制轉(zhuǎn)換

二進(jìn)制轉(zhuǎn)換成十進(jìn)制：v = “0b1111011”

十進(jìn)制轉(zhuǎn)換成二進(jìn)制：v = 18

八進(jìn)制轉(zhuǎn)換成十進(jìn)制：v = “011”

十進(jìn)制轉(zhuǎn)換成八進(jìn)制：v = 30

十六進(jìn)制轉(zhuǎn)換成十進(jìn)制：v = “0x12”

十進(jìn)制轉(zhuǎn)換成十六進(jìn)制：v = 87

1. 二進(jìn)制數(shù)、轉(zhuǎn)換為十進(jìn)制數(shù)的規(guī)律是:把二進(jìn)制數(shù)按位權(quán)形式展開多項(xiàng)式和的形式，求其最后的和，就是其對應(yīng)的十進(jìn)制數(shù)——簡稱“按權(quán)求和”。
2. 十進(jìn)制整數(shù)轉(zhuǎn)換為二進(jìn)制整數(shù)采用"除2取余，逆序排列"法。具體做法是：用2去除十進(jìn)制整數(shù)，可以得到一個商和余數(shù)；再用2去除商，又會得到一個商和余數(shù)，如此進(jìn)行，直到商為零時為止，然后把先得到的余數(shù)作為二進(jìn)制數(shù)的低位有效位，后得到的余數(shù)作為二進(jìn)制數(shù)的高位有效位，依次排列起來。

10進(jìn)制，當(dāng)然是便于我們?nèi)祟悂硎褂?，我們從小的?xí)慣就是使用十進(jìn)制，這個毋庸置疑。
2進(jìn)制，是供計(jì)算機(jī)使用的，1，0代表開和關(guān)，有和無，機(jī)器只認(rèn)識2進(jìn)制。
16進(jìn)制，內(nèi)存地址空間是用16進(jìn)制的數(shù)據(jù)表示, 如0x8039326。

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

  ## 如 10.3.9.12 轉(zhuǎn)換規(guī)則為：
  ##         10            00001010
  ##          3            00000011
  ##          9            00001001
  ##         12            00001100
  ## 再將以上二進(jìn)制拼接起來計(jì)算十進(jìn)制結(jié)果：00001010 00000011 00001001 00001100 = ？

  ip_addr='192.168.2.10'
  # transfer ip to int
  def ip2long(ip):
      ip_list=ip.split('.')
      result=0
      for i in range(4):  #0,1,2,3
          result=result+int(ip_list[i])*256**(3-i)
      return result

  long=3232236042

  # transfer int to ip
  def long2ip(long):
      floor_list=[]
      yushu=long
      for i in reversed(range(4)):   #3,2,1,0
          res=divmod(yushu,256**i)
          floor_list.append(str(res[0]))
          yushu=res[1]
      return '.'.join(floor_list)
  a=long2ip(long)
  print(a)

7、python遞歸的最大層數(shù)？？====>998

8、求邏輯運(yùn)算符的結(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

結(jié)論：
真假比 若都真
or選前 and選后

9、ASCII、Unicode、utf-8、gbk區(qū)別？
http://www.cnblogs.com/zhuwenlubin/p/5131026.html

10、字節(jié)碼和機(jī)器碼的區(qū)別

機(jī)器碼
機(jī)器碼(machine code)，學(xué)名機(jī)器語言指令，有時也被稱為原生碼（Native Code），是電腦的CPU可直接解讀的數(shù)據(jù)。

通常意義上來理解的話，機(jī)器碼就是計(jì)算機(jī)可以直接執(zhí)行，并且執(zhí)行速度最快的代碼。

用機(jī)器語言編寫程序，編程人員要首先熟記所用計(jì)算機(jī)的全部指令代碼和代碼的涵義。手編程序時，程序員得自己處理每條指令和每一數(shù)據(jù)的存儲分配和輸入輸出，還得記住編程過程中每步所使用的工作單元處在何種狀態(tài)。這是一件十分繁瑣的工作，編寫程序花費(fèi)的時間往往是實(shí)際運(yùn)行時間的幾十倍或幾百倍。而且，編出的程序全是些0和1的指令代碼，直觀性差，還容易出錯?，F(xiàn)在，除了計(jì)算機(jī)生產(chǎn)廠家的專業(yè)人員外，絕大多數(shù)的程序員已經(jīng)不再去學(xué)習(xí)機(jī)器語言了。

機(jī)器語言是微處理器理解和使用的，用于控制它的操作二進(jìn)制代碼。
8086到Pentium的機(jī)器語言指令長度可以從1字節(jié)到13字節(jié)。
盡管機(jī)器語言好像是很復(fù)雜的，然而它是有規(guī)律的。
存在著多至100000種機(jī)器語言的指令。這意味著不能把這些種類全部列出來。
總結(jié)：機(jī)器碼是電腦CPU直接讀取運(yùn)行的機(jī)器指令，運(yùn)行速度最快，但是非?；逎y懂，也比較難編寫，一般從業(yè)人員接觸不到。

字節(jié)碼
字節(jié)碼（Bytecode）是一種包含執(zhí)行程序、由一序列 op 代碼/數(shù)據(jù)對 組成的二進(jìn)制文件。字節(jié)碼是一種中間碼，它比機(jī)器碼更抽象，需要直譯器轉(zhuǎn)譯后才能成為機(jī)器碼的中間代碼。

通常情況下它是已經(jīng)經(jīng)過編譯，但與特定機(jī)器碼無關(guān)。字節(jié)碼通常不像源碼一樣可以讓人閱讀，而是編碼后的數(shù)值常量、引用、指令等構(gòu)成的序列。

字節(jié)碼主要為了實(shí)現(xiàn)特定軟件運(yùn)行和軟件環(huán)境、與硬件環(huán)境無關(guān)。字節(jié)碼的實(shí)現(xiàn)方式是通過編譯器和虛擬機(jī)器。編譯器將源碼編譯成字節(jié)碼，特定平臺上的虛擬機(jī)器將字節(jié)碼轉(zhuǎn)譯為可以直接執(zhí)行的指令。字節(jié)碼的典型應(yīng)用為Java bytecode。

字節(jié)碼在運(yùn)行時通過JVM（JAVA虛擬機(jī)）做一次轉(zhuǎn)換生成機(jī)器指令，因此能夠更好的跨平臺運(yùn)行。

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

11、三元運(yùn)算規(guī)則和應(yīng)用場景？簡化if語句

12、舉例python2和python3的區(qū)別
py2和py3:

1. 文件操作： xreadlines

f = open('x.log','rb')

for line in f.xreadlines():
print(line)

f.close()

2. 字符串：
   py2:
   str: 字符串 -> 字節(jié)
   unicode: u"sdfsdf"
   py3:
   bytes:
   str:

3. 默認(rèn)解釋器編碼
   py2: ascii
   py3: utf-8

py2: range/xrange
py3: range

py2: int / long
py3: int

7. input/raw_input

py2: yield
py3: yield/yield from

py2: 新式類和經(jīng)典類
py3: 新式類

13、用一行代碼實(shí)現(xiàn)數(shù)值交換。a, b = b, a

14、python3和python2中int和long的區(qū)別
python3 徹底廢棄了 long+int 雙整數(shù)實(shí)現(xiàn)的方法, 統(tǒng)一為 int , 支持高精度整數(shù)運(yùn)算.

15、xrange和range的區(qū)別
函數(shù)說明：和range 的用法完全相同，但是返回的是一個生成器。

16、文件操作時，xreadlines和readlines的區(qū)別

1. read([size])方法從文件當(dāng)前位置起讀取size個字節(jié)，若無參數(shù)size，則表示讀取至文件結(jié)束為止，它范圍為字符串對象
2. 從字面意思可以看出，該方法每次讀出一行內(nèi)容，所以，讀取時占用內(nèi)存小，比較適合大文件，該方法返回一個字符串對象。
3. readlines()方法讀取整個文件所有行，保存在一個列表(list)變量中，每行作為一個元素，但讀取大文件會比較占內(nèi)存。

17、列舉布爾值為False的常見值
布爾型，F(xiàn)alse表示False，其他為True
整數(shù)和浮點(diǎn)數(shù)，0表示False，其他為True
字符串和類字符串類型（包括bytes和unicode），空字符串表示False，其他為True
序列類型（包括tuple，list，dict，set等），空表示False，非空表示True
None永遠(yuǎn)表示False

18、字符串，列表，元組，字典，集合五個常用方法

• 字符串 split/strip/replace/find/index ...
  • 列表 append/extend/insert/push/pop/reverse/sort ...
  • 元組 len/max/min/count/index ...
  • 字典 keys/values/pop/clear/del ...
  • 集合　 add/remove/clear/交集&、并集 |、差集 -
  • collections Python內(nèi)建的一個集合模塊，提供了許多有用的集合類。
    1.Counter是一個簡單的計(jì)數(shù)器，例如，統(tǒng)計(jì)字符出現(xiàn)的個數(shù);
    2.OrderedDict可以實(shí)現(xiàn)一個FIFO（先進(jìn)先出）的dict，當(dāng)容量超出限制時，先刪除最早添加的Key;
    3.deque是為了高效實(shí)現(xiàn)插入和刪除操作的雙向列表，適合用于隊(duì)列和棧;
    4.defaultdict使用dict時，如果引用的Key不存在，就會拋出KeyError。如果希望key不存在時，返回一個默認(rèn)值，就可以用defaultdict;

19、lambda表達(dá)式的格式以及應(yīng)用場景
省去函數(shù)命名的煩惱
http://www.cnblogs.com/guigujun/p/6134828.html

20、pass的作用
當(dāng)你在編寫一個程序時，執(zhí)行語句部分思路還沒有完成，這時你可以用pass語句來占位，也可以當(dāng)做是一個標(biāo)記，是要過后來完成的代碼

21、args和kwargs的作用
*args：（表示的就是將實(shí)參中按照位置傳值，多出來的值都給args，且以元組的方式呈現(xiàn)）
**kwargs：（表示的就是形參中按照關(guān)鍵字傳值把多余的傳值以字典的方式呈現(xiàn)）
http://www.cnblogs.com/xuyuanyuan123/p/6674645.html

22、is和==的區(qū)別
is 比較的是兩個實(shí)例對象是不是完全相同，它們是不是同一個對象，占用的內(nèi)存地址是否相同。萊布尼茨說過：“世界上沒有兩片完全相同的葉子”，這個is正是這樣的比較，比較是不是同一片葉子（即比較的id是否相同，這id類似于人的身份證標(biāo)識）。

== 比較的是兩個對象的內(nèi)容是否相等，即內(nèi)存地址可以不一樣，內(nèi)容一樣就可以了。這里比較的并非是同一片葉子，可能葉子的種類或者脈絡(luò)相同就可以了。默認(rèn)會調(diào)用對象的 eq()方法。

23、簡述python深淺拷貝以及應(yīng)用場景
Python采用基于值得內(nèi)存管理模式，賦值語句的執(zhí)行過程是：首先把等號右側(cè)標(biāo)識的表達(dá)式計(jì)算出來，然后在內(nèi)存中找一個位置把值存放進(jìn)去，最后創(chuàng)建變量并指向這個內(nèi)存地址。Python中的變量并不直接存儲值，而是存儲了值的內(nèi)存地址或者引用
簡單地說，淺拷貝只拷貝一層（如果有嵌套），深拷貝拷貝所有層。
一層的情況：
import copy

# 淺拷貝

li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

# 深拷貝

li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

多層的情況：
import copy

# 淺拷貝

li1 = [1, 2, 3, [4, 5], 6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]

# 深拷貝

li1 = [1, 2, 3, [4, 5], 6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]

24、Python垃圾回收機(jī)制
Python GC主要使用引用計(jì)數(shù)（reference counting）來跟蹤和回收垃圾。在引用計(jì)數(shù)的基礎(chǔ)上，通過“標(biāo)記-清除”（mark and sweep）解決容器對象可能產(chǎn)生的循環(huán)引用問題，通過“分代回收”（generation collection）以空間換時間的方法提高垃圾回收效率。

1 引用計(jì)數(shù)

PyObject是每個對象必有的內(nèi)容，其中ob_refcnt就是做為引用計(jì)數(shù)。當(dāng)一個對象有新的引用時，它的ob_refcnt就會增加，當(dāng)引用它的對象被刪除，它的ob_refcnt就會減少.引用計(jì)數(shù)為0時，該對象生命就結(jié)束了。

優(yōu)點(diǎn):

簡單 實(shí)時性 缺點(diǎn):

維護(hù)引用計(jì)數(shù)消耗資源 循環(huán)引用

2 標(biāo)記-清除機(jī)制

基本思路是先按需分配，等到?jīng)]有空閑內(nèi)存的時候從寄存器和程序棧上的引用出發(fā)，遍歷以對象為節(jié)點(diǎn)、以引用為邊構(gòu)成的圖，把所有可以訪問到的對象打上標(biāo)記，然后清掃一遍內(nèi)存空間，把所有沒標(biāo)記的對象釋放。

3 分代技術(shù)

分代回收的整體思想是：將系統(tǒng)中的所有內(nèi)存塊根據(jù)其存活時間劃分為不同的集合，每個集合就成為一個“代”，垃圾收集頻率隨著“代”的存活時間的增大而減小，存活時間通常利用經(jīng)過幾次垃圾回收來度量。

Python默認(rèn)定義了三代對象集合，索引數(shù)越大，對象存活時間越長。

http://python.jobbole.com/82061/

25、python的可變數(shù)據(jù)類型和不可變數(shù)據(jù)類型
在Python中不可變對象指：一旦創(chuàng)建就不可修改的對象，包括字符串，元組，數(shù)字

在Python中可變對象是指：可以修改的對象，包括：列表、字典

26、求可變數(shù)據(jù)類型的結(jié)果
v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v) # {'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v) # {'k1': 777, 'k2': [666]}

27、求匿名函數(shù)的結(jié)果
def num():
return[lambda x: i*x for i in range(4)]

print([m(2) for m in num()]) # [6, 6, 6, 6]

28、列舉常見的內(nèi)置函數(shù)
long(x)
float(x) # 把x轉(zhuǎn)換成浮點(diǎn)數(shù)
complex(x) # 轉(zhuǎn)換成復(fù)數(shù)
str(x) # 轉(zhuǎn)換成字符串
list(x) # 轉(zhuǎn)換成列表
tuple(x) # 轉(zhuǎn)換成元組

進(jìn)制相互轉(zhuǎn)換
 r= bin(10) #二進(jìn)制
 r= int(10) #十進(jìn)制

 r = oct(10) #八進(jìn)制
 r = hex(10) #十六進(jìn)制
 i= int("11",base=10)#進(jìn)制間的相互轉(zhuǎn)換base后跟 2/8/10/16
 print(i)
 
chr(x)//返回x對應(yīng)的字符，如chr(65)返回‘A'
ord(x)//返回字符對應(yīng)的ASC碼數(shù)字編號，如ord('A')返回65
abs(),all(),any(),bin(),bool(),bytes(),chr(),dict()dir(),divmod(),enumerate(),eval(),filter(),float(),gloabls(),help(),hex(),id(),input(),int(),isinstance(),len(),list(),locals(),map(),max(),min(),oct(),open(),ord(),pow(),print(),range(),round(),set(),type(),sorted(),str(),sum(),tuple()

29、filter、map、reduce的作用
filter:對于序列中的元素進(jìn)行篩選，最終獲取符合條件的序列
map:遍歷序列，對序列中每個元素進(jìn)行操作，最終獲取新的序列
reduce:對于序列內(nèi)所有元素進(jìn)行累計(jì)操作

30、一行代碼實(shí)現(xiàn)99乘法表
print("\n".join("\t".join(["%s%s=%s" %(x,y,xy) for y in range(1, x+1)]) for x in range(1, 10)) )

31、如何安裝第三方模塊，以及用過哪些模塊

• pip包管理器
  • 源碼安裝
    • 下載->解壓->cd 到對應(yīng)路徑
    • python setup.py build
    • python setup.py install

32、常見的模塊有哪些
re/json/logging/os/sys/requests/beautifulsoup4

33、re模塊的match和search的區(qū)別
match和search的區(qū)別

re.match只匹配字符串的開始，如果字符串開始不符合正則表達(dá)式，則匹配失敗，函數(shù)返回None；
re.search匹配整個字符串，直到找到一個匹配。

34、什么是正則的貪婪匹配
貪婪和非貪婪
正則表達(dá)式通常用于在文本中查找匹配的字符串。Python里數(shù)量詞默認(rèn)是貪婪的（在少數(shù)語言里也可能是默認(rèn)非貪婪），總是嘗試匹配盡可能多的字符；非貪婪則相反，總是嘗試匹配盡可能少的字符。在"*","?","+","{m,n}"后面加上？，使貪婪變成非貪婪。

35、求結(jié)果：a.[ i % 2 for i in range(10)]和b.( i % 2 for i in range(10))
[ i % 2 for i in range(10) ] # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
( i % 2 for i in range(10) ) # <generator object <genexpr> at 0x0000000003180FC0>

36、求結(jié)果：a 1 or 2 b 1 and 2 c 1 < (2==2) d 1 < 2 == 2
1
1
False
True

37、def func(a, b=[])寫法有什么問題
def func(a, b=[]):
b.append(a)
return b

s = func(1)
print(s) # [1]
s = func(1)
print(s) # [1, 1]

第二次調(diào)用的時候 b的初始值是[1]了

38、如何實(shí)現(xiàn)“1，2，3”變成['1', '2', '3']
list("1,2,3".split(','))

39、如何實(shí)現(xiàn)['1', '2', '3']變成[1, 2, 3]
[int(x) for x in ['1','2','3']]

40、比較：a=[1, 2, 3]和b=[(1), (2), (3)]以及b=[(1,), (2,), (3,)]的區(qū)別
前兩個列表內(nèi)是int
最后一個列表內(nèi)是元組

41、用一行代碼生成[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
i*i for i in range(1,11)]

42、一行代碼實(shí)現(xiàn)刪除列表重復(fù)的值
list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

43、如何在函數(shù)中設(shè)置一個全局變量
在函數(shù)中定義的局部變量如果和全局變量同名，則它會隱藏該全局變量。如果想在函數(shù)中使用全局變量，則需要使用global進(jìn)行聲明。

44、logging模塊的作用以及應(yīng)用場景
logging模塊是Python內(nèi)置的標(biāo)準(zhǔn)模塊，主要用于輸出運(yùn)行日志，可以設(shè)置輸出日志的等級、日志保存路徑、日志文件回滾等；相比print，具備如下優(yōu)點(diǎn)：

可以通過設(shè)置不同的日志等級，在release版本中只輸出重要信息，而不必顯示大量的調(diào)試信息；

print將所有信息都輸出到標(biāo)準(zhǔn)輸出中，嚴(yán)重影響開發(fā)者從標(biāo)準(zhǔn)輸出中查看其它數(shù)據(jù)；logging則可以由開發(fā)者決定將信息輸出到什么地方，以及怎么輸出。
https://www.cnblogs.com/testdjt/p/7834856.html

45、請用代碼實(shí)現(xiàn)一個棧

# 后進(jìn)先出
  class Stack():
      def __init__(self, size):
          self.size = size
          self.stack = []
          self.top = -1

      # 入棧之前檢查棧是否已滿
      def push(self, x):
          if self.isfull():
              raise exception("stack is full")
          else:
              self.stack.append(x)
              self.top = self.top + 1

      # 出棧之前檢查棧是否為空
      def pop(self):
          if self.isempty():
              raise exception("stack is empty")
          else:
              self.top = self.top - 1
              self.stack.pop()

      def isfull(self):
          return self.top + 1 == self.size

      def isempty(self):
          return self.top == '-1'

      def showStack(self):
          print(self.stack)


  s = Stack(10)
  for i in range(6):
      s.push(i)  # 入棧
  s.showStack()  # [0, 1, 2, 3, 4, 5]

  for i in range(2):
      s.pop()  # 出棧
  s.showStack()  # [0, 1, 2, 3]

46、簡述生成器、迭代器、可迭代對象以及應(yīng)用場景
如果給定一個list或tuple，我們可以通過for循環(huán)來遍歷這個list或tuple，這種遍歷我們稱為迭代（Iteration）剛才說過，很多容器都是可迭代對象，此外還有更多的對象同樣也是可迭代對象，比如處于打開狀態(tài)的files，sockets等等。但凡是可以返回一個 迭代器 的對象都可稱之為可迭代對象
那么什么迭代器呢？它是一個帶狀態(tài)的對象，他能在你調(diào)用 next() 方法的時候返回容器中的下一個值，任何實(shí)現(xiàn)了 next() （python2中實(shí)現(xiàn) next() ）方法的對象都是迭代器
生成器算得上是Python語言中最吸引人的特性之一，生成器其實(shí)是一種特殊的迭代器，不過這種迭代器更加優(yōu)雅。生成器（yield）不需要再像上面的類一樣寫 iter() 和 next() 方法了，只需要一個 yiled 關(guān)鍵字。 生成器有如下特征是它一定也是迭代器（反之不成立），因此任何生成器也是以一種懶加載的模式生成值。
http://www.cnblogs.com/yuanchenqi/articles/5769491.html

47、用Python實(shí)現(xiàn)一個二分查找函數(shù)
def bin_search_rec(data_set, value, low, high):
if low <= high:
mid = (low + high) // 2
if data_set[mid] == value:
return mid
elif data_set[mid] > value:
return bin_search_rec(data_set, value, low, mid - 1)
else:
return bin_search_rec(data_set, value, mid + 1, high)
else:
return

48、談?wù)剬﹂]包的理解
https://www.cnblogs.com/Lin-Yi/p/7305364.html

49、os和sys模塊的作用
os就是一個普通的python庫，用來向Python程序提供運(yùn)行環(huán)境，特別是在文件系統(tǒng)、創(chuàng)建新進(jìn)程、獲取操作系統(tǒng)本身的一些信息（比如uname)，并屏蔽各種不同操作系統(tǒng)之間的細(xì)節(jié)差異。
sys模塊則是python程序用來請求解釋器行為的接口。比如關(guān)于調(diào)試類的（trace, frames，except）等，profiling類（stats， getsizeof)，運(yùn)行時環(huán)境類（python path, stderr, stdout)，解釋器本身（如version）。inspect某種程度上可以看成是在sys提供的功能上的一個包裝。

50、如何生成一個隨機(jī)數(shù)
random.randint(a,b)

51、如何使用Python刪除一個文件
刪除子目錄
os.rmdir( path ) # path: "要刪除的子目錄"

產(chǎn)生異常的可能原因:
(1) path 不存在
(2) path 子目錄中有文件或下級子目錄
(3) 沒有操作權(quán)限或只讀

刪除文件
os.remove( filename ) # filename: "要刪除的文件名"

產(chǎn)生異常的可能原因:
(1) filename 不存在
(2) 對filename文件， 沒有操作權(quán)限或只讀。

52、談?wù)勀銓γ嫦驅(qū)ο蟮睦斫?br> 從三大特性說起：繼承、封裝、多態(tài)

封裝：
起始就是將很多數(shù)據(jù)封裝到一個對象中，類似于把很多東西放到一個箱子中，
如：一個函數(shù)如果好多參數(shù)，起始就可以把參數(shù)封裝到一個對象再傳遞。

  在哪里用過：
    - django rest framework中的request對象。
    - flask中：ctx_context/app_context對象

繼承：
如果多個類中都有共同的方法，那么為了避免反復(fù)編寫，就可以將方法提取到基類中實(shí)現(xiàn)，
讓所有派生類去繼承即可。

  在哪里用過？
    - 視圖
    - 版本、認(rèn)證、分頁

多態(tài)：
python本身就是多態(tài)的，崇尚鴨子模型，只要會呱呱叫的就是鴨子。
def func(arg):
arg.send()
https://www.cnblogs.com/iyouyue/p/8535796.html

53、Python中面向?qū)ο笾械睦^承有什么特點(diǎn)
Python3的繼承機(jī)制
子類在調(diào)用某個方法或變量的時候，首先在自己內(nèi)部查找，如果沒有找到，則開始根據(jù)繼承機(jī)制在父類里查找。
根據(jù)父類定義中的順序，以深度優(yōu)先的方式逐一查找父類！
繼承參數(shù)的書寫有先后順序，寫在前面的被優(yōu)先繼承。

54、面向?qū)ο蟮纳疃葍?yōu)先和廣度優(yōu)先是什么
繼承順序
http://www.liujiangblog.com/course/python/44

55、面向?qū)ο笾衧uper的作用
我們都知道，在子類中如果有與父類同名的成員，那就會覆蓋掉父類里的成員。那如果你想強(qiáng)制調(diào)用父類的成員呢？使用super()函數(shù)！這是一個非常重要的函數(shù)，最常見的就是通過super調(diào)用父類的實(shí)例化方法init！

語法：super(子類名, self).方法名()，需要傳入的是子類名和self，調(diào)用的是父類里的方法，按父類的方法需要傳入?yún)?shù)。
class A:
def init(self, name):
self.name = name
print("父類的init方法被執(zhí)行了！")
def show(self):
print("父類的show方法被執(zhí)行了！")

class B(A):
def init(self, name, age):
super(B, self).init(name=name)
self.age = age

  def show(self):
      super(B, self).show()

obj = B("jack", 18)
obj.show()

56、是否有用過functools的函數(shù)，其作用是什么
1.functools.partial
官網(wǎng)文檔說的真是不好理解,就當(dāng)作是把一個函數(shù)，綁定部分或者全部參數(shù)后生成一個新版本的函數(shù)
2.functools.partialwrap
文檔說的比較詳細(xì)，如果不使用這個wraps，那么原始函數(shù)的name和doc都會丟失
https://blog.csdn.net/secretx/article/details/51700361

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

__init__ :      構(gòu)造函數(shù)，在生成對象時調(diào)用
  __del__ :       析構(gòu)函數(shù)，釋放對象時使用
  __repr__ :      打印，轉(zhuǎn)換
  __setitem__ :   按照索引賦值
  __getitem__:    按照索引獲取值
  __len__:        獲得長度
  __cmp__:        比較運(yùn)算
  __call__:       調(diào)用
  __add__:        加運(yùn)算
  __sub__:        減運(yùn)算
  __mul__:        乘運(yùn)算
  __div__:        除運(yùn)算
  __mod__:        求余運(yùn)算
  __pow__:        冪
  https://ltoddy.github.io/essay/2018/05/27/python-magic-methods.html

58、如何判斷是函數(shù)還是方法
print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # True

示例:
class Foo(object):
def init(self):
self.name = 'lcg'

  def func(self):
      print(self.name)

obj = Foo()
print(obj.func) # <bound method Foo.func of <main.Foo object at 0x000001ABC0F15F98>>

print(Foo.func) # <function Foo.func at 0x000001ABC1F45BF8>

------------------------FunctionType, MethodType------------#

from types import FunctionType, MethodType

obj = Foo()
print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # True

print(isinstance(Foo.func, FunctionType)) # True
print(isinstance(Foo.func, MethodType)) # False

------------------------------------------------------------#

obj = Foo()
Foo.func(obj) # lcg

obj = Foo()
obj.func() # lcg

"""
注意：
方法，無需傳入self參數(shù)
函數(shù)，必須手動傳入self參數(shù)
"""

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

classmethod 必須有一個指向類對象的引用作為第一個參數(shù)，而 staticmethod 可以沒有任何參數(shù)

  class Num:
      # 普通方法：能用Num調(diào)用而不能用實(shí)例化對象調(diào)用   
      def one():  
          print ('1')
   
      # 實(shí)例方法：能用實(shí)例化對象調(diào)用而不能用Num調(diào)用
      def two(self):
          print ('2')
   
      # 靜態(tài)方法：能用Num和實(shí)例化對象調(diào)用
      @staticmethod 
      def three():  
          print ('3')
   
      # 類方法：第一個參數(shù)cls長什么樣不重要，都是指Num類本身，調(diào)用時將Num類作為對象隱式地傳入方法   
      @classmethod 
      def go(cls): 
          cls.three() 
   
  Num.one()          #1
  #Num.two()         #TypeError: two() missing 1 required positional argument: 'self'
  Num.three()        #3
  Num.go()           #3
   
  i=Num()                
  #i.one()           #TypeError: one() takes 0 positional arguments but 1 was given         
  i.two()            #2      
  i.three()          #3
  i.go()             #3 

60、列舉面向?qū)ο笾械奶厥獬蓡T和應(yīng)用場景
http://www.cnblogs.com/bainianminguo/p/8076329.html

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

i = 0
  for x in range(1, 6):
      for y in range(1, 6):
          for z in range(1, 6):
              if (x != y) and (y != z) and (z != x):
                  i += 1
                  if i % 4:
                      print("%d%d%d" % (x, y, z), end=" | ")
                  else:
                      print("%d%d%d" % (x, y, z))
  print(i)

62、什么是反射以及應(yīng)用場景
反射就是通過字符串的形式，導(dǎo)入模塊；通過字符串的形式，去模塊尋找指定函數(shù)，并執(zhí)行。利用字符串的形式去對象（模塊）中操作（查找/獲取/刪除/添加）成員，一種基于字符串的事件驅(qū)動！
https://www.cnblogs.com/vipchenwei/p/6991209.html

63、metaclass作用以及應(yīng)用場景
metaclass用來指定類是由誰創(chuàng)建的。

類的metaclass 默認(rèn)是type。我們也可以指定類的metaclass值。
http://www.cnblogs.com/0bug/p/8578747.html

64、用盡量多的方法來實(shí)現(xiàn)單例模式
http://python.jobbole.com/87294/
http://www.cnblogs.com/0bug/p/8576802.html
常用方式：
使用模塊
使用 new
使用裝飾器（decorator）
使用元類（metaclass）

65、裝飾器的寫法和應(yīng)用場景
裝飾器的應(yīng)用場景：比如插入日志，性能測試，事務(wù)處理，緩存等等場景。
def outer(func):
def inner(args,kwargs):
print("認(rèn)證成功！")
result = func(args,**kwargs)
print("日志添加成功")
return result
return inner

@outer
def f1(name,age):
print("%s 正在連接業(yè)務(wù)部門1數(shù)據(jù)接口......"%name)

調(diào)用方法

f1("jack",18)
http://www.cnblogs.com/iyouyue/p/8934547.html

66、異常處理寫法以及如何主動拋出異常和應(yīng)用場景
while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")

raise主動拋出一個異常
http://www.runoob.com/python3/python3-errors-execptions.html

67、什么是面向?qū)ο蟮膍ro
mro就是方法解析順序。
方法解析順序Method Resolution Order
參考：http://www.cnblogs.com/0bug/p/8728570.html#_label8

68、isinstance作用以及應(yīng)用場景
用于判斷一個對象是否是一個類或者其子類的實(shí)例。
class A:
pass

class b(A):
pass

class c(b):
pass

bb = b()

print(isinstance(bb, A)) # True
print(isinstance(bb, b)) # True
print(isinstance(bb, c)) # False

69、寫代碼并實(shí)現(xiàn)LeetCodde兩數(shù)之和

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]

class Solution:
def twoSum(self,nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
#用len()方法取得nums列表長度
n = len(nums)
#x從0到n取值（不包括n）
for x in range(n):
a = target - nums[x]
#用in關(guān)鍵字查詢nums列表中是否有a
if a in nums:
#用index函數(shù)取得a的值在nums列表中的索引
y = nums.index(a)
#假如x=y,那么就跳過,否則返回x,y
if x == y:
continue
else:
return x,y
break
else :
continue
https://blog.csdn.net/linfeng886/article/details/79772348

70、json序列化時，可以處理的數(shù)據(jù)類型有哪些？如何定制支持datetime類型
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))

{"name": "alex", "data": "2018-05-18 19:52:05"}

https://www.cnblogs.com/tkqasn/p/6005025.html

71、json序列化時，遇到中文默認(rèn)會轉(zhuǎn)化成Unicode，如果要保留中文怎么做
在序列化時，中文漢字總是被轉(zhuǎn)換為unicode碼，在dumps函數(shù)中添加參數(shù)ensure_ascii=False即可解決。

72、什么是斷言，應(yīng)用場景
python assert斷言是聲明其布爾值必須為真的判定，如果發(fā)生異常就說明表達(dá)示為假
比如我想測試 a==1。就可以用斷言。如果我的猜想錯誤就會拋出異常，可以用于測試一段表達(dá)式是否成立。

73、有用過with statement嗎？它的好處是什么
with語句適用于對資源進(jìn)行訪問的場合，確保不管使用過程中是否發(fā)生異常都會執(zhí)行必要的“清理”操作，釋放資源，比如文件使用后自動關(guān)閉、線程中鎖的自動獲取和釋放等。

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

# 方法一：（不使用os.walk）
  def print_directory_contents(sPath):
      import os

      for sChild in os.listdir(sPath):
          sChildPath = os.path.join(sPath, sChild)
          if os.path.isdir(sChildPath):
              print_directory_contents(sChildPath)
          else:
              print(sChildPath)
              
  # 方法二：（使用os.walk）
  def print_directory_contents(sPath):
      import os
      for root, _, filenames in os.walk(sPath):
          for filename in filenames:
              print(os.path.abspath(os.path.join(root, filename)))

  print_directory_contents('已知路徑')

sPath-- 是你所要便利的目錄的地址, 返回的是一個三元組(root,dirs,files)。
root 所指的是當(dāng)前正在遍歷的這個文件夾的本身的地址
_ 是一個 list ，內(nèi)容是該文件夾中所有的目錄的名字(不包括子目錄)
filenames 同樣是 list , 內(nèi)容是該文件夾中所有的文件(不包括子目錄)

75、簡述yield和yield from關(guān)鍵字
https://blog.csdn.net/chenbin520/article/details/78111399?locationNum=7&fps=1