Python語言特性

1 Python的函數(shù)參數(shù)傳遞

看兩個如下例子陵且，分析運行結(jié)果:

代碼一：

a = 1

def fun(a):

????a = 2

fun(a)

print(a)??# 1

代碼二：

a = []

def fun(a):

a.append(1)

fun(a)

print(a)??# [1]

所有的變量都可以理解是內(nèi)存中一個對象的“引用”代芜，或者爹梁，也可以看似c中void*的感覺椰苟。

這里記住的是類型是屬于對象的，而不是變量。而對象有兩種,“可更改”（mutable）與“不可更改”（immutable）對象紊选。在python中亥宿，strings, tuples, 和numbers是不可更改的對象，而list,dict等則是可以修改的對象浆劲。(這就是這個問題的重點)

當(dāng)一個引用傳遞給函數(shù)的時候,函數(shù)自動復(fù)制一份引用,這個函數(shù)里的引用和外邊的引用沒有半毛關(guān)系了.所以第一個例子里函數(shù)把引用指向了一個不可變對象,當(dāng)函數(shù)返回的時候,外面的引用沒半毛感覺.而第二個例子就不一樣了,函數(shù)內(nèi)的引用指向的是可變對象,對它的操作就和定位了指針地址一樣,在內(nèi)存里進(jìn)行修改.

2 Python中的元類(metaclass)

元類就是用來創(chuàng)建類的“東西”嫌术。你創(chuàng)建類就是為了創(chuàng)建類的實例對象，但是我們已經(jīng)學(xué)習(xí)到了Python中的類也是對象牌借。好吧度气，元類就是用來創(chuàng)建這些類（對象）的，元類就是類的類

這個非常的不常用,詳情請看：《深刻理解Python中的元類(metaclass)》

3 @staticmethod和@classmethod

Python其實有3個方法,即靜態(tài)方法(staticmethod),類方法(classmethod)和實例方法,如下:

class A(object):

????def foo(self,x):

????????print "executing foo(%s,%s)"%(self,x)

????@classmethod

????def class_foo(cls,x):

????????print(?"executing class_foo(%s,%s)"%(cls,x))

????@staticmethod

????def static_foo(x):

????????print ("executing static_foo(%s)"%x)

a=A()

這里先理解下函數(shù)參數(shù)里面的self和cls.這個self和cls是對類或者實例的綁定.對于實例方法,我們知道在類里每次定義方法的時候都需要綁定這個實例,就是foo(self, x),為什么要這么做呢?因為實例方法的調(diào)用離不開實例,我們需要把實例自己傳給函數(shù),調(diào)用的時候是這樣的a.foo(x)(其實是foo(a, x)).類方法一樣,只不過它傳遞的是類而不是實例,A.class_foo(x).注意這里的self和cls可以替換別的參數(shù),但是python的約定是這倆,還是不要改的好.

對于靜態(tài)方法其實和普通的方法一樣,不需要對誰進(jìn)行綁定,唯一的區(qū)別是調(diào)用的時候需要使用a.static_foo(x)或者A.static_foo(x)來調(diào)用.

\實例方法類方法靜態(tài)方法

a = A()a.foo(x)a.class_foo(x)a.static_foo(x)

A不可用A.class_foo(x)A.static_foo(x)

4 類變量和實例變量

?class Person:

????name="aaa"

p1=Person()

p2=Person()

p1.name="bbb"

print(p1.name)??# bbb

print(p2.name)??# aaa

print(Person.name)??# aaa

類變量就是供類使用的變量,實例變量就是供實例使用的.

這里p1.name="bbb"是實例調(diào)用了類變量,這其實和上面第一個問題一樣,就是函數(shù)傳參的問題,p1.name一開始是指向的類變量name="aaa",但是在實例的作用域里把類變量的引用改變了,就變成了一個實例變量,self.name不再引用Person的類變量name了.

可以看看下面的例子:

?class Person:

????name=[]

p1=Person()

p2=Person()

p1.name.append(1)

print(p1.name)??# [1]

print(p2.name)??# [1]

print(Person.name)??# [1]

5 Python自省

這個也是python彪悍的特性.

自省就是面向?qū)ο蟮恼Z言所寫的程序在運行時,所能知道對象的類型.簡單一句就是運行時能夠獲得對象的類型.比如type(),dir(),getattr(),hasattr(),isinstance().

6 字典推導(dǎo)式

可能你見過列表推導(dǎo)時,卻沒有見過字典推導(dǎo)式,在2.7中才加入的:

?d = {key: value for (key, value) in iterable}

7 Python中單下劃線和雙下劃線

>>> class MyClass():

...???? def __init__(self):

...???????????? self.__superprivate = "Hello"

...???????????? self._semiprivate = ", world!"

...

>>> mc = MyClass()

>>> print(mc.__superprivate)

Traceback (most recent call last):

??File "", line 1, in

AttributeError: myClass instance has no attribute '__superprivate'

>>> print(mc._semiprivate)

, world!

>>> print mc.__dict__

{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

__foo__:一種約定,Python內(nèi)部的名字,用來區(qū)別其他用戶自定義的命名,以防沖突.

_foo:一種約定,用來指定變量私有.程序員用來指定私有變量的一種方式.

__foo:這個有真正的意義:解析器用_classname__foo來代替這個名字,以區(qū)別和其他類相同的命名.

詳情見:

http://www.zhihu.com/question/19754941

8 字符串格式化:%和.format

.format在許多方面看起來更便利.對于%最煩人的是它無法同時傳遞一個變量和元組.你可能會想下面的代碼不會有什么問題:

Python:

?"hi there %s" % name

但是,如果name恰好是(1,2,3),它將會拋出一個TypeError異常.為了保證它總是正確的,你必須這樣做:

?"hi there %s" % (name,)?? # 提供一個單元素的數(shù)組而不是一個參數(shù)

9 迭代器和生成器

在Python中膨报，這種一邊循環(huán)一邊計算的機制磷籍，稱為生成器：generator适荣。

可以被next()函數(shù)調(diào)用并不斷返回下一個值的對象稱為迭代器：Iterator。

這個是stackoverflow里python排名第一的問題,值得一看: http://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do-in-python

10?*args?and?**kwargs

用*args和**kwargs只是為了方便并沒有強制使用它們.

當(dāng)你不確定你的函數(shù)里將要傳遞多少參數(shù)時你可以用*args.例如,它可以傳遞任意數(shù)量的參數(shù):

>>> def print_everything(*args):

????????for count, thing in enumerate(args):

...???????? print '{0}. {1}'.format(count, thing)

...

>>> print_everything('apple', 'banana', 'cabbage')

0. apple

1. banana

2. cabbage

相似的,**kwargs允許你使用沒有事先定義的參數(shù)名:

>>> def table_things(**kwargs):

...???? for name, value in kwargs.items():

...???????? print '{0} = {1}'.format(name, value)

...

>>> table_things(apple = 'fruit', cabbage = 'vegetable')

cabbage = vegetable

apple = fruit

你也可以混著用.命名參數(shù)首先獲得參數(shù)值然后所有的其他參數(shù)都傳遞給*args和**kwargs.命名參數(shù)在列表的最前端.例如:

1def table_things(titlestring, **kwargs)

*args和**kwargs可以同時在函數(shù)的定義中,但是*args必須在**kwargs前面.

當(dāng)調(diào)用函數(shù)時你也可以用*和**語法.例如:

>>> def print_three_things(a, b, c):

...???? print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)

...

>>> mylist = ['aardvark', 'baboon', 'cat']

>>> print_three_things(*mylist)

a = aardvark, b = baboon, c = cat

就像你看到的一樣,它可以傳遞列表(或者元組)的每一項并把它們解包.注意必須與它們在函數(shù)里的參數(shù)相吻合.當(dāng)然,你也可以在函數(shù)定義或者函數(shù)調(diào)用時用*.

http://stackoverflow.com/questions/3394835/args-and-kwargs

11 面向切面編程AOP和裝飾器

這個AOP一聽起來有點懵,同學(xué)面試的時候就被問懵了…

裝飾器是一個很著名的設(shè)計模式院领，經(jīng)常被用于有切面需求的場景弛矛，較為經(jīng)典的有插入日志、性能測試栅盲、事務(wù)處理等汪诉。裝飾器是解決這類問題的絕佳設(shè)計，有了裝飾器谈秫，我們就可以抽離出大量函數(shù)中與函數(shù)功能本身無關(guān)的雷同代碼并繼續(xù)重用扒寄。概括的講，裝飾器的作用就是為已經(jīng)存在的對象添加額外的功能拟烫。

這個問題比較大,推薦: http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python

中文: http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/3/README.html

12 鴨子類型

“當(dāng)看到一只鳥走起來像鴨子该编、游泳起來像鴨子、叫起來也像鴨子硕淑，那么這只鳥就可以被稱為鴨子课竣。”

我們并不關(guān)心對象是什么類型置媳，到底是不是鴨子于樟，只關(guān)心行為。

比如在python中拇囊，有很多file-like的東西迂曲，比如StringIO,GzipFile,socket。它們有很多相同的方法寥袭，我們把它們當(dāng)作文件使用路捧。

又比如list.extend()方法中,我們并不關(guān)心它的參數(shù)是不是list,只要它是可迭代的,所以它的參數(shù)可以是list/tuple/dict/字符串/生成器等.

鴨子類型在動態(tài)語言中經(jīng)常使用，非常靈活传黄，使得python不想java那樣專門去弄一大堆的設(shè)計模式杰扫。

13 Python中重載

引自知乎:http://www.zhihu.com/question/20053359

函數(shù)重載主要是為了解決兩個問題。

[if !supportLists]1.?[endif]可變參數(shù)類型膘掰。

[if !supportLists]2.?[endif]可變參數(shù)個數(shù)章姓。

另外，一個基本的設(shè)計原則是识埋，僅僅當(dāng)兩個函數(shù)除了參數(shù)類型和參數(shù)個數(shù)不同以外凡伊，其功能是完全相同的，此時才使用函數(shù)重載惭聂，如果兩個函數(shù)的功能其實不同窗声，那么不應(yīng)當(dāng)使用重載，而應(yīng)當(dāng)使用一個名字不同的函數(shù)辜纲。

好吧笨觅，那么對于情況1 拦耐，函數(shù)功能相同，但是參數(shù)類型不同见剩，python 如何處理杀糯？答案是根本不需要處理，因為 python 可以接受任何類型的參數(shù)苍苞，如果函數(shù)的功能相同固翰，那么不同的參數(shù)類型在 python 中很可能是相同的代碼，沒有必要做成兩個不同函數(shù)羹呵。

那么對于情況2 骂际，函數(shù)功能相同，但參數(shù)個數(shù)不同冈欢，python 如何處理歉铝？大家知道，答案就是缺省參數(shù)凑耻。對那些缺少的參數(shù)設(shè)定為缺省參數(shù)即可解決問題太示。因為你假設(shè)函數(shù)功能相同，那么那些缺少的參數(shù)終歸是需要用的香浩。

好了类缤，鑒于情況1 跟 情況 2 都有了解決方案，python 自然就不需要函數(shù)重載了邻吭。

14 新式類和舊式類

這個面試官問了,我說了老半天,不知道他問的真正意圖是什么.

這篇文章很好的介紹了新式類的特性: http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html

新式類很早在2.2就出現(xiàn)了,所以舊式類完全是兼容的問題,Python3里的類全部都是新式類.這里有一個MRO問題可以了解下(新式類是廣度優(yōu)先,舊式類是深度優(yōu)先),里講的也很多.

15?__new__和__init__的區(qū)別

這個__new__確實很少見到,先做了解吧.

[if !supportLists]1.?[endif]__new__是一個靜態(tài)方法,而__init__是一個實例方法.

[if !supportLists]2.?[endif]__new__方法會返回一個創(chuàng)建的實例,而__init__什么都不返回.

[if !supportLists]3.?[endif]只有在__new__返回一個cls的實例時后面的__init__才能被調(diào)用.

[if !supportLists]4.?[endif]當(dāng)創(chuàng)建一個新實例時調(diào)用__new__,初始化一個實例時用__init__.

ps:?__metaclass__是創(chuàng)建類時起作用.所以我們可以分別使用__metaclass__,__new__和__init__來分別在類創(chuàng)建,實例創(chuàng)建和實例初始化的時候做一些小手腳.

16 單例模式

這個絕對巢腿酰考啊.絕對要記住1~2個方法,當(dāng)時面試官是讓手寫的.

1使用__new__方法

?class?Singleton(object):

????def?__new__(cls,?*args,?**kw):

????????if?not?hasattr(cls,?'_instance'):

????????????orig?=?super(Singleton,?cls)

????????????cls._instance?=?orig.__new__(cls,?*args,?**kw)

????????return?cls._instance

class?MyClass(Singleton):

????a?=?1

2共享屬性

創(chuàng)建實例時把所有實例的__dict__指向同一個字典,這樣它們具有相同的屬性和方法.

class?Borg(object):

????_state?=?{}

????def?__new__(cls,?*args,?**kw):

????????ob?=?super(Borg,?cls).__new__(cls,?*args,?**kw)

????????ob.__dict__?=?cls._state

????????return?ob

class?MyClass2(Borg):

????a?=?1

3裝飾器版本

def?singleton(cls,?*args,?**kw):

????instances?=?{}

????def?getinstance():

????????if?cls not?in?instances:

????????????instances[cls]?=?cls(*args,?**kw)

????????return?instances[cls]

????return?getinstance

@singleton

class?MyClass:

4 import方法

作為python的模塊是天然的單例模式

?# mysingleton.py

class?My_Singleton(object):

????def?foo(self):

????????pass

my_singleton?=?My_Singleton()

# to use

from?mysingleton import?my_singleton

my_singleton.foo()

17 Python中的作用域

Python 中，一個變量的作用域總是由在代碼中被賦值的地方所決定的镜盯。

當(dāng)Python 遇到一個變量的話他會按照這樣的順序進(jìn)行搜索：

本地作用域（Local）→當(dāng)前作用域被嵌入的本地作用域（Enclosing locals）→全局/模塊作用域（Global）→內(nèi)置作用域（Built-in）

18 GIL線程全局鎖

線程全局鎖(Global Interpreter Lock),即Python為了保證線程安全而采取的獨立線程運行的限制,說白了就是一個核只能在同一時間運行一個線程.

解決辦法就是多進(jìn)程和下面的協(xié)程(協(xié)程也只是單CPU,但是能減小切換代價提升性能).

19 協(xié)程

簡單點說協(xié)程是進(jìn)程和線程的升級版,進(jìn)程和線程都面臨著內(nèi)核態(tài)和用戶態(tài)的切換問題而耗費許多切換時間,而協(xié)程就是用戶自己控制切換的時機,不再需要陷入系統(tǒng)的內(nèi)核態(tài).

Python里最常見的yield就是協(xié)程的思想!可以查看第九個問題.

20 閉包

閉包(closure)是函數(shù)式編程的重要的語法結(jié)構(gòu)岸裙。閉包也是一種組織代碼的結(jié)構(gòu)猖败，它同樣提高了代碼的可重復(fù)使用性速缆。

當(dāng)一個內(nèi)嵌函數(shù)引用其外部作作用域的變量,我們就會得到一個閉包. 總結(jié)一下,創(chuàng)建一個閉包必須滿足以下幾點:

[if !supportLists]1.?[endif]必須有一個內(nèi)嵌函數(shù)

[if !supportLists]2.?[endif]內(nèi)嵌函數(shù)必須引用外部函數(shù)中的變量

[if !supportLists]3.?[endif]外部函數(shù)的返回值必須是內(nèi)嵌函數(shù)

感覺閉包還是有難度的,幾句話是說不明白的,還是查查相關(guān)資料.

重點是函數(shù)運行后并不會被撤銷,就像16題的instance字典一樣,當(dāng)函數(shù)運行完后,instance并不被銷毀,而是繼續(xù)留在內(nèi)存空間里.這個功能類似類里的類變量,只不過遷移到了函數(shù)上.

閉包就像個空心球一樣,你知道外面和里面,但你不知道中間是什么樣.

21 lambda函數(shù)

其實就是一個匿名函數(shù),為什么叫l(wèi)ambda?因為和后面的函數(shù)式編程有關(guān).

22 Python函數(shù)式編程

這個需要適當(dāng)?shù)牧私庖幌掳?畢竟函數(shù)式編程在Python中也做了引用.

python中函數(shù)式編程支持:

filter 函數(shù)的功能相當(dāng)于過濾器。調(diào)用一個布爾函數(shù)bool_func來迭代遍歷每個seq中的元素恩闻；返回一個使bool_seq返回值為true的元素的序列艺糜。

?>>>a?=?[1,2,3,4,5,6,7]

>>>b?=?filter(lambda?x:?x?>?5,?a)

>>>print?b

>>>[6,7]

map函數(shù)是對一個序列的每個項依次執(zhí)行函數(shù)，下面是對一個序列每個項都乘以2：

?>>>?a?=?map(lambda?x:x*2,[1,2,3])

>>>?list(a)

[2,?4,?6]

reduce函數(shù)是對一個序列的每個項迭代調(diào)用函數(shù)幢尚，下面是求3的階乘：

?>>>?reduce(lambda?x,y:x*y,range(1,4))

6

23 Python里的拷貝

引用和copy(),deepcopy()的區(qū)別

import?copy

a?=?[1,?2,?3,?4,?['a',?'b']]??#原始對象

b?=?a??#賦值破停，傳對象的引用

c?=?copy.copy(a)??#對象拷貝，淺拷貝

d?=?copy.deepcopy(a)??#對象拷貝尉剩，深拷貝

a.append(5)??#修改對象a

a[4].append('c')??#修改對象a中的['a', 'b']數(shù)組對象

print?'a = ',?a

print?'b = ',?b

print?'c = ',?c

print?'d = ',?d

輸出結(jié)果：

a?=??[1,?2,?3,?4,?['a',?'b',?'c'],?5]

b?=??[1,?2,?3,?4,?['a',?'b',?'c'],?5]

c?=??[1,?2,?3,?4,?['a',?'b',?'c']]

d?=??[1,?2,?3,?4,?['a',?'b']]

24 Python垃圾回收機制

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

1 引用計數(shù)

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

優(yōu)點:

[if !supportLists]1.?[endif]簡單

[if !supportLists]2.?[endif]實時性

缺點:

[if !supportLists]1.?[endif]維護(hù)引用計數(shù)消耗資源

[if !supportLists]2.?[endif]循環(huán)引用

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

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

3 分代技術(shù)

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

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

舉例：當(dāng)某些內(nèi)存塊M經(jīng)過了3次垃圾收集的清洗之后還存活時页衙，我們就將內(nèi)存塊M劃到一個集合A中去，而新分配的內(nèi)存都劃分到集合B中去阴绢。當(dāng)垃圾收集開始工作時店乐，大多數(shù)情況都只對集合B進(jìn)行垃圾回收，而對集合A進(jìn)行垃圾回收要隔相當(dāng)長一段時間后才進(jìn)行呻袭，這就使得垃圾收集機制需要處理的內(nèi)存少了眨八，效率自然就提高了。在這個過程中左电，集合B中的某些內(nèi)存塊由于存活時間長而會被轉(zhuǎn)移到集合A中廉侧，當(dāng)然，集合A中實際上也存在一些垃圾篓足，這些垃圾的回收會因為這種分代的機制而被延遲段誊。

25 Python里面如何實現(xiàn)tuple和list的轉(zhuǎn)換？

答：tuple栈拖，可以說是不可變的list连舍，訪問方式還是通過索引下標(biāo)的方式。當(dāng)你明確定義個tuple是涩哟，如果僅有一個元素，必須帶有,例如：(1,)。當(dāng)然弓坞，在2.7以后的版，python里還增加了命名式的tuple强岸！至于有什么用，首先第一點砾赔，樓主玩過python都知道蝌箍，python的函數(shù)可以有多返回值的，而python里暴心，多返回值妓盲，就是用tuple來表示，這是用的最廣的了专普，比如說悯衬，你需要定義一個常量的列表，但你又不想使用list檀夹，那也可以是要你管tuple筋粗，例如：if a in ('A','B','C'):pass

26 Python的is

is是對比地址,==是對比值

27 read,readline和readlines

[if !supportLists]·?[endif]read 讀取整個文件

[if !supportLists]·?[endif]readline 讀取下一行,使用生成器方法

[if !supportLists]·?[endif]readlines 讀取整個文件到一個迭代器以供我們遍歷

28 Python2和3的區(qū)別

大部分Python庫都同時支持Python 2.7.x和3.x版本的，所以不論選擇哪個版本都是可以的炸渡。但為了在使用Python時避開某些版本中一些常見的陷阱娜亿，或需要移植某個Python項目

使用__future__模塊

print函數(shù)

整數(shù)除法

Unicode

xrange

觸發(fā)異常

處理異常

next()函數(shù)和.next()方法

For循環(huán)變量與全局命名空間泄漏

比較無序類型

使用input()解析輸入內(nèi)容

返回可迭代對象，而不是列表

推薦：《Python 2.7.x 和 3.x 版本的重要區(qū)別》

29到底什么是Python蚌堵？你可以在回答中與其他技術(shù)進(jìn)行對比

答案

下面是一些關(guān)鍵點：

[if !supportLists]·?[endif]Python是一種解釋型語言买决。這就是說，與C語言和C的衍生語言不同吼畏，Python代碼在運行之前不需要編譯督赤。其他解釋型語言還包括PHP和Ruby。

[if !supportLists]·?[endif]Python是動態(tài)類型語言泻蚊，指的是你在聲明變量時躲舌，不需要說明變量的類型。你可以直接編寫類似x=111和x="I'm a string"這樣的代碼藕夫，程序不會報錯孽糖。

[if !supportLists]·?[endif]Python非常適合面向?qū)ο蟮木幊蹋∣OP）枯冈，因為它支持通過組合（composition）與繼承（inheritance）的方式定義類（class）毅贮。Python中沒有訪問說明符（access specifier，類似C++中的public和private）尘奏，這么設(shè)計的依據(jù)是“大家都是成年人了”滩褥。

[if !supportLists]·?[endif]在Python語言中，函數(shù)是第一類對象（first-class objects）炫加。這指的是它們可以被指定給變量瑰煎，函數(shù)既能返回函數(shù)類型铺然，也可以接受函數(shù)作為輸入。類（class）也是第一類對象酒甸。

[if !supportLists]·?[endif]Python代碼編寫快魄健，但是運行速度比編譯語言通常要慢。好在Python允許加入基于C語言編寫的擴展插勤，因此我們能夠優(yōu)化代碼沽瘦，消除瓶頸，這點通常是可以實現(xiàn)的农尖。numpy就是一個很好地例子析恋，它的運行速度真的非常快盛卡，因為很多算術(shù)運算其實并不是通過Python實現(xiàn)的助隧。

[if !supportLists]·?[endif]Python用途非常廣泛——網(wǎng)絡(luò)應(yīng)用，自動化滑沧，科學(xué)建模并村，大數(shù)據(jù)應(yīng)用，等等滓技。它也常被用作“膠水語言”橘霎，幫助其他語言和組件改善運行狀況。

[if !supportLists]·?[endif]Python讓困難的事情變得容易殖属，因此程序員可以專注于算法和數(shù)據(jù)結(jié)構(gòu)的設(shè)計姐叁，而不用處理底層的細(xì)節(jié)。

為什么提這個問題：

如果你應(yīng)聘的是一個Python開發(fā)崗位洗显，你就應(yīng)該知道這是門什么樣的語言外潜，以及它為什么這么酷。以及它哪里不好挠唆。

30補充缺失的代碼

def print_directory_contents(sPath):

????"""

這個函數(shù)接受文件夾的名稱作為輸入?yún)?shù)处窥，

返回該文件夾中文件的路徑，

以及其包含文件夾中文件的路徑玄组。

????"""

????# 補充代碼

答案

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

特別要注意以下幾點：

[if !supportLists]·?[endif]命名規(guī)范要統(tǒng)一滔驾。如果樣本代碼中能夠看出命名規(guī)范，遵循其已有的規(guī)范俄讹。

[if !supportLists]·?[endif]遞歸函數(shù)需要遞歸并終止哆致。確保你明白其中的原理，否則你將面臨無休無止的調(diào)用棧（callstack）患膛。

[if !supportLists]·?[endif]我們使用os模塊與操作系統(tǒng)進(jìn)行交互摊阀，同時做到交互方式是可以跨平臺的。你可以把代碼寫成sChildPath = sPath + '/' + sChild，但是這個在Windows系統(tǒng)上會出錯胞此。

[if !supportLists]·?[endif]熟悉基礎(chǔ)模塊是非常有價值的臣咖，但是別想破腦袋都背下來，記住Google是你工作中的良師益友漱牵。

[if !supportLists]·?[endif]如果你不明白代碼的預(yù)期功能夺蛇，就大膽提問。

[if !supportLists]·?[endif]堅持KISS原則酣胀！保持簡單蚊惯，不過腦子就能懂！

為什么提這個問題：

[if !supportLists]·?[endif]說明面試者對與操作系統(tǒng)交互的基礎(chǔ)知識

[if !supportLists]·?[endif]遞歸真是太好用啦

31閱讀下面的代碼灵临，寫出A0截型，A1至An的最終值。

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))

A1 = range(10)

A2 = [i for i in A1 if i in A0]

A3 = [A0[s] for s in A0]

A4 = [i for i in A1 if i in A3]

A5 = {i:i*i for i in A1}

A6 = [[i,i*i] for i in A1]

答案

A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}

A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A2 = []

A3 = [1, 3, 2, 5, 4]

A4 = [1, 2, 3, 4, 5]

A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]

為什么提這個問題：

[if !supportLists]·?[endif]列表解析（list comprehension）十分節(jié)約時間儒溉，對很多人來說也是一個大的學(xué)習(xí)障礙宦焦。

[if !supportLists]·?[endif]如果你讀懂了這些代碼，就很可能可以寫下正確地值顿涣。

[if !supportLists]·?[endif]其中部分代碼故意寫的怪怪的波闹。因為你共事的人之中也會有怪人。

32下面代碼會輸出什么：

def f(x,l=[]):

????for i in range(x):

????????l.append(i*i)

????print(l)

f(2)

f(3,[3,2,1])

f(3)

答案：

[0, 1]

[3, 2, 1, 0, 1, 4]

[0, 1, 0, 1, 4]

呃涛碑？

第一個函數(shù)調(diào)用十分明顯精堕，for循環(huán)先后將0和1添加至了空列表l中。l是變量的名字蒲障，指向內(nèi)存中存儲的一個列表歹篓。第二個函數(shù)調(diào)用在一塊新的內(nèi)存中創(chuàng)建了新的列表。l這時指向了新生成的列表揉阎。之后再往新列表中添加0庄撮、1和4。很棒吧毙籽。第三個函數(shù)調(diào)用的結(jié)果就有些奇怪了洞斯。它使用了之前內(nèi)存地址中存儲的舊列表。這就是為什么它的前兩個元素是0和1了坑赡。

33你如何管理不同版本的代碼烙如？

答案：

版本管理！被問到這個問題的時候毅否，你應(yīng)該要表現(xiàn)得很興奮亚铁，甚至告訴他們你是如何使用Git（或是其他你最喜歡的工具）追蹤自己和奶奶的書信往來。我偏向于使用Git作為版本控制系統(tǒng)（VCS）搀突，但還有其他的選擇刀闷，比如subversion（SVN）熊泵。

為什么提這個問題：

因為沒有版本控制的代碼仰迁，就像沒有杯子的咖啡甸昏。有時候我們需要寫一些一次性的、可以隨手扔掉的腳本徐许，這種情況下不作版本控制沒關(guān)系施蜜。但是如果你面對的是大量的代碼，使用版本控制系統(tǒng)是有利的雌隅。版本控制能夠幫你追蹤誰對代碼庫做了什么操作翻默；發(fā)現(xiàn)新引入了什么bug；管理你的軟件的不同版本和發(fā)行版恰起；在團(tuán)隊成員中分享源代碼修械；部署及其他自動化處理。它能讓你回滾到出現(xiàn)問題之前的版本检盼，單憑這點就特別棒了肯污。還有其他的好功能。怎么一個棒字了得吨枉！

34“猴子補丁”（monkey patching）指的是什么蹦渣？這種做法好嗎？

答案：

“猴子補丁”就是指貌亭，在函數(shù)或?qū)ο笠呀?jīng)定義之后柬唯，再去改變它們的行為。

舉個例子：

import datetime

datetime.datetime.now = lambda: datetime.datetime(2012, 12, 12)

大部分情況下圃庭，這是種很不好的做法- 因為函數(shù)在代碼庫中的行為最好是都保持一致锄奢。打“猴子補丁”的原因可能是為了測試。mock包對實現(xiàn)這個目的很有幫助剧腻。

為什么提這個問題斟薇？

答對這個問題說明你對單元測試的方法有一定了解。你如果提到要避免“猴子補丁”恕酸，可以說明你不是那種喜歡花里胡哨代碼的程序員（公司里就有這種人堪滨，跟他們共事真是糟糕透了），而是更注重可維護(hù)性蕊温。還記得KISS原則碼袱箱？答對這個問題還說明你明白一些Python底層運作的方式，函數(shù)實際是如何存儲义矛、調(diào)用等等发笔。

另外：如果你沒讀過mock模塊的話，真的值得花時間讀一讀凉翻。這個模塊非常有用了讨。

35閱讀下面的代碼，它的輸出結(jié)果是什么？

class A(object):

????def go(self):

????????print "go A go!"

????def stop(self):

????????print "stop A stop!"

????def pause(self):

????????raise Exception("Not Implemented")

class B(A):

????def go(self):

????????super(B, self).go()

????????print "go B go!"

class C(A):

????def go(self):

????????super(C, self).go()

????????print "go C go!"

????def stop(self):

????????super(C, self).stop()

????????print "stop C stop!"

class D(B,C):

????def go(self):

????????super(D, self).go()

????????print "go D go!"

????def stop(self):

????????super(D, self).stop()

????????print "stop D stop!"

????def pause(self):

????????print "wait D wait!"

class E(B,C): pass

a = A()

b = B()

c = C()

d = D()

e = E()

# 說明下列代碼的輸出結(jié)果

a.go()

b.go()

c.go()

d.go()

e.go()

a.stop()

b.stop()

c.stop()

d.stop()

e.stop()

a.pause()

b.pause()

c.pause()

d.pause()

e.pause()

答案

輸出結(jié)果以注釋的形式表示：

a.go()

# go A go!

b.go()

# go A go!

# go B go!

c.go()

# go A go!

# go C go!

d.go()

# go A go!

# go C go!

# go B go!

# go D go!

e.go()

# go A go!

# go C go!

# go B go!

a.stop()

# stop A stop!

b.stop()

# stop A stop!

c.stop()

# stop A stop!

# stop C stop!

d.stop()

# stop A stop!

# stop C stop!

# stop D stop!

e.stop()

# stop A stop!

a.pause()

# ... Exception: Not Implemented

b.pause()

# ... Exception: Not Implemented

c.pause()

# ... Exception: Not Implemented

d.pause()

# wait D wait!

e.pause()

# ...Exception: Not Implemented

為什么提這個問題前计？

因為面向?qū)ο蟮木幊陶娴恼娴暮苤匾贰２或_你。答對這道問題說明你理解了繼承和Python中super函數(shù)的用法男杈。

36閱讀下面的代碼丈屹，它的輸出結(jié)果是什么？

class Node(object):

????def __init__(self,sName):

????????self._lChildren = []

????????self.sName = sName

????def __repr__(self):

????????return "".format(self.sName)

????def append(self,*args,**kwargs):

????????self._lChildren.append(*args,**kwargs)

????def print_all_1(self):

????????print self

????????for oChild in self._lChildren:

????????????oChild.print_all_1()

????def print_all_2(self):

????????def gen(o):

????????????lAll = [o,]

????????????while lAll:

????????????????oNext = lAll.pop(0)

????????????????lAll.extend(oNext._lChildren)

????????????????yield oNext

????????for oNode in gen(self):

????????????print oNode

oRoot = Node("root")

oChild1 = Node("child1")

oChild2 = Node("child2")

oChild3 = Node("child3")

oChild4 = Node("child4")

oChild5 = Node("child5")

oChild6 = Node("child6")

oChild7 = Node("child7")

oChild8 = Node("child8")

oChild9 = Node("child9")

oChild10 = Node("child10")

oRoot.append(oChild1)

oRoot.append(oChild2)

oRoot.append(oChild3)

oChild1.append(oChild4)

oChild1.append(oChild5)

oChild2.append(oChild6)

oChild4.append(oChild7)

oChild3.append(oChild8)

oChild3.append(oChild9)

oChild6.append(oChild10)

# 說明下面代碼的輸出結(jié)果

oRoot.print_all_1()

oRoot.print_all_2()

答案

oRoot.print_all_1()會打印下面的結(jié)果：

oRoot.print_all_1()會打印下面的結(jié)果：

為什么提這個問題伶棒？

因為對象的精髓就在于組合（composition）與對象構(gòu)造（object construction）旺垒。對象需要有組合成分構(gòu)成，而且得以某種方式初始化肤无。這里也涉及到遞歸和生成器（generator）的使用先蒋。

生成器是很棒的數(shù)據(jù)類型秸谢。你可以只通過構(gòu)造一個很長的列表绣溜，然后打印列表的內(nèi)容，就可以取得與print_all_2類似的功能槐臀。生成器還有一個好處皇忿，就是不用占據(jù)很多內(nèi)存畴蹭。

有一點還值得指出，就是print_all_1會以深度優(yōu)先（depth-first）的方式遍歷樹(tree),而print_all_2則是寬度優(yōu)先（width-first）鳍烁。有時候叨襟，一種遍歷方式比另一種更合適。但這要看你的應(yīng)用的具體情況幔荒。

36.介紹一下except的用法和作用糊闽？

答：try…except…except…[else…][finally…]

執(zhí)行try下的語句，如果引發(fā)異常爹梁，則執(zhí)行過程會跳到except語句右犹。對每個except分支順序嘗試執(zhí)行，如果引發(fā)的異常與except中的異常組匹配姚垃，執(zhí)行相應(yīng)的語句念链。如果所有的except都不匹配，則異常會傳遞到下一個調(diào)用本代碼的最高層try代碼中积糯。

try下的語句正常執(zhí)行掂墓，則執(zhí)行else塊代碼。如果發(fā)生異常看成，就不會執(zhí)行

如果存在finally語句君编，最后總是會執(zhí)行。

37.Python中pass語句的作用是什么川慌？

答：pass語句不會執(zhí)行任何操作吃嘿，一般作為占位符或者創(chuàng)建占位程序祠乃，whileFalse:pass

38.介紹一下Python下range()函數(shù)的用法？

答：列出一組數(shù)據(jù)兑燥，經(jīng)常用在for ?in range()循環(huán)中

39.如何用Python來進(jìn)行查詢和替換一個文本字符串亮瓷？

答：可以使用re模塊中的sub()函數(shù)或者subn()函數(shù)來進(jìn)行查詢和替換，

格式：sub(replacement, string[,count=0])（replacement是被替換成的文本贪嫂，string是需要被替換的文本寺庄，count是一個可選參數(shù)艾蓝，指最大被替換的數(shù)量）

>>> import re

>>>p=re.compile(‘blue|white|red’)

>>>print(p.sub(‘colour’,'blue socks and red shoes’))

colour socks and colourshoes

>>>print(p.sub(‘colour’,'blue socks and red shoes’,count=1))

colour socks and redshoes

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

40.Python里面match()和search()的區(qū)別赢织？

答：re模塊中match(pattern,string[,flags]),檢查string的開頭是否與pattern匹配亮靴。

re模塊中research(pattern,string[,flags]),在string搜索pattern的第一個匹配值。

>>>print(re.match(‘super’, ‘superstition’).span())

(0, 5)

>>>print(re.match(‘super’, ‘insuperable’))

None

>>>print(re.search(‘super’, ‘superstition’).span())

(0, 5)

>>>print(re.search(‘super’, ‘insuperable’).span())

(2, 7)

41.用Python匹配HTML tag的時候于置，<.*>和<.*?>有什么區(qū)別茧吊？

答：術(shù)語叫貪婪匹配( <.*> )和非貪婪匹配(<.*?> )

例如:

test

<.*> :

test

<.*?> :

42.Python里面如何生成隨機數(shù)？

答：random模塊

隨機整數(shù)：random.randint(a,b)：返回隨機整數(shù)x,a<=x<=b

random.randrange(start,stop,[,step])：返回一個范圍在(start,stop,step)之間的隨機整數(shù)八毯，不包括結(jié)束值搓侄。

隨機實數(shù)：random.random( ):返回0到1之間的浮點數(shù)

random.uniform(a,b):返回指定范圍內(nèi)的浮點數(shù)。

43.有沒有一個工具可以幫助查找python的bug和進(jìn)行靜態(tài)的代碼分析话速？

答：PyChecker是一個python代碼的靜態(tài)分析工具讶踪，它可以幫助查找python代碼的bug, 會對代碼的復(fù)雜度和格式提出警告

Pylint是另外一個工具可以進(jìn)行codingstandard檢查

44.如何在一個function里面設(shè)置一個全局的變量？

答：解決方法是在function的開始插入一個global聲明：

def f()

global x

45.單引號泊交，雙引號乳讥，三引號的區(qū)別

答：單引號和雙引號是等效的，如果要換行廓俭，需要符號(\),三引號則可以直接換行云石，并且可以包含注釋

如果要表示Let’s go 這個字符串

單引號：s4 = ‘Let\’s go’

雙引號：s5 = “Let’s go”

s6 = ‘I realy like“python”!’

這就是單引號和雙引號都可以表示字符串的原因了

46 Python和多線程（multi-threading）。這是個好主意碼研乒？列舉一些讓Python代碼以并行方式運行的方法汹忠。

答案

Python并不支持真正意義上的多線程。Python中提供了多線程包雹熬，但是如果你想通過多線程提高代碼的速度宽菜，使用多線程包并不是個好主意。Python中有一個被稱為Global Interpreter Lock（GIL）的東西橄唬，它會確保任何時候你的多個線程中赋焕，只有一個被執(zhí)行。線程的執(zhí)行速度非常之快仰楚，會讓你誤以為線程是并行執(zhí)行的隆判，但是實際上都是輪流執(zhí)行犬庇。經(jīng)過GIL這一道關(guān)卡處理，會增加執(zhí)行的開銷侨嘀。這意味著臭挽，如果你想提高代碼的運行速度，使用threading包并不是一個很好的方法咬腕。

不過還是有很多理由促使我們使用threading包的欢峰。如果你想同時執(zhí)行一些任務(wù)，而且不考慮效率問題涨共，那么使用這個包是完全沒問題的纽帖，而且也很方便。但是大部分情況下举反，并不是這么一回事懊直，你會希望把多線程的部分外包給操作系統(tǒng)完成（通過開啟多個進(jìn)程），或者是某些調(diào)用你的Python代碼的外部程序（例如Spark或Hadoop）火鼻，又或者是你的Python代碼調(diào)用的其他代碼（例如室囊，你可以在Python中調(diào)用C函數(shù)，用于處理開銷較大的多線程工作）魁索。

為什么提這個問題

因為GIL就是個混賬東西（A-hole）融撞。很多人花費大量的時間，試圖尋找自己多線程代碼中的瓶頸粗蔚，直到他們明白GIL的存在尝偎。

47 將下面的函數(shù)按照執(zhí)行效率高低排序。

它們都接受由0至1之間的數(shù)字構(gòu)成的列表作為輸入支鸡。這個列表可以很長冬念。一個輸入列表的示例如下：[random.random() for i in range(100000)]。你如何證明自己的答案是正確的牧挣。

def f1(lIn):

????l1 = sorted(lIn)

????l2 = [i for i in l1 if i<0.5]

????return [i*i for i in l2]

def f2(lIn):

????l1 = [i for i in lIn if i<0.5]

????l2 = sorted(l1)

????return [i*i for i in l2]

def f3(lIn):

????l1 = [i*i for i in lIn]

????l2 = sorted(l1)

????return [i for i in l1 if i<(0.5*0.5)]

答案

按執(zhí)行效率從高到低排列：f2急前、f1和f3。要證明這個答案是對的瀑构，你應(yīng)該知道如何分析自己代碼的性能裆针。Python中有一個很好的程序分析包，可以滿足這個需求寺晌。

import cProfile

lIn = [random.random() for i in range(100000)]

cProfile.run('f1(lIn)')

cProfile.run('f2(lIn)')

cProfile.run('f3(lIn)')

為了向大家進(jìn)行完整地說明世吨，下面我們給出上述分析代碼的輸出結(jié)果：

>>> cProfile.run('f1(lIn)')

?????????4 function calls in 0.045 seconds

???Ordered by: standard name

???ncalls ?tottime ?percall ?cumtime ?percall filename:lineno(function)

????????1 ???0.009 ???0.009 ???0.044 ???0.044 :1(f1)

????????1 ???0.001 ???0.001 ???0.045 ???0.045 :1()

????????1 ???0.000 ???0.000 ???0.000 ???0.000 {method 'disable' of '_lsprof.Profiler' objects}

????????1 ???0.035 ???0.035 ???0.035 ???0.035 {sorted}

>>> cProfile.run('f2(lIn)')

?????????4 function calls in 0.024 seconds

???Ordered by: standard name

???ncalls ?tottime ?percall ?cumtime ?percall filename:lineno(function)

????????1 ???0.008 ???0.008 ???0.023 ???0.023 :1(f2)

????????1 ???0.001 ???0.001 ???0.024 ???0.024 :1()

????????1 ???0.000 ???0.000 ???0.000 ???0.000 {method 'disable' of '_lsprof.Profiler' objects}

????????1 ???0.016 ???0.016 ???0.016 ???0.016 {sorted}

>>> cProfile.run('f3(lIn)')

?????????4 function calls in 0.055 seconds

???Ordered by: standard name

???ncalls ?tottime ?percall ?cumtime ?percall filename:lineno(function)

????????1 ???0.016 ???0.016 ???0.054 ???0.054 :1(f3)

????????1 ???0.001 ???0.001 ???0.055 ???0.055 :1()

????????1 ???0.000 ???0.000 ???0.000 ???0.000 {method 'disable' of '_lsprof.Profiler' objects}

????????1 ???0.038 ???0.038 ???0.038 ???0.038 {sorted}

為什么提這個問題？

定位并避免代碼瓶頸是非常有價值的技能呻征。想要編寫許多高效的代碼耘婚，最終都要回答常識上來——在上面的例子中，如果列表較小的話陆赋，很明顯是先進(jìn)行排序更快沐祷，因此如果你可以在排序前先進(jìn)行篩選嚷闭，那通常都是比較好的做法。其他不顯而易見的問題仍然可以通過恰當(dāng)?shù)墓ぞ邅矶ㄎ焕盗佟Ｒ虼肆私膺@些工具是有好處的胞锰。

48.如何用Python來進(jìn)行查詢和替換一個文本字符串？

可以使用sub()方法來進(jìn)行查詢和替換兢榨，sub方法的格式為：sub(replacement, string[, count=0])replacement是被替換成的文本string是需要被替換的文本count是一個可選參數(shù)嗅榕，指最大被替換的數(shù)量49.Python里面search()和match()的區(qū)別？

match()函數(shù)只檢測RE是不是在string的開始位置匹配吵聪，search()會掃描整個string查找匹配, 也就是說match()只有在0位置匹配成功的話才有返回凌那，如果不是開始位置匹配成功的話，match()就返回none

50.用Python匹配HTML tag的時候暖璧，<.*>和<.*?>有什么區(qū)別案怯？

前者是貪婪匹配君旦，會從頭到尾匹配xyz澎办，而后者是非貪婪匹配，只匹配到第一個 >金砍。

51.Python里面如何生成隨機數(shù)局蚀？

import randomrandom.random()它會返回一個隨機的0和1之間的浮點數(shù)

操作系統(tǒng)

1 select,poll和epoll

其實所有的I/O都是輪詢的方法,只不過實現(xiàn)的層面不同罷了.

這個問題可能有點深入了,但相信能回答出這個問題是對I/O多路復(fù)用有很好的了解了.其中tornado使用的就是epoll的.

基本上select有3個缺點:

[if !supportLists]1.?[endif]連接數(shù)受限

[if !supportLists]2.?[endif]查找配對速度慢

[if !supportLists]3.?[endif]數(shù)據(jù)由內(nèi)核拷貝到用戶態(tài)

poll改善了第一個缺點

epoll改了三個缺點.

2 調(diào)度算法

[if !supportLists]1.?[endif]先來先服務(wù)(FCFS, First Come First Serve)

[if !supportLists]2.?[endif]短作業(yè)優(yōu)先(SJF, Shortest Job First)

[if !supportLists]3.?[endif]最高優(yōu)先權(quán)調(diào)度(Priority Scheduling)

[if !supportLists]4.?[endif]時間片輪轉(zhuǎn)(RR, Round Robin)

[if !supportLists]5.?[endif]多級反饋隊列調(diào)度(multilevel feedback queue scheduling)

實時調(diào)度算法:

[if !supportLists]1.?[endif]最早截至?xí)r間優(yōu)先EDF

[if !supportLists]2.?[endif]最低松弛度優(yōu)先LLF

3 死鎖

原因:

[if !supportLists]1.?[endif]競爭資源

[if !supportLists]2.?[endif]程序推進(jìn)順序不當(dāng)

必要條件:

[if !supportLists]1.?[endif]互斥條件

[if !supportLists]2.?[endif]請求和保持條件

[if !supportLists]3.?[endif]不剝奪條件

[if !supportLists]4.?[endif]環(huán)路等待條件

處理死鎖基本方法:

[if !supportLists]1.?[endif]預(yù)防死鎖(摒棄除1以外的條件)

[if !supportLists]2.?[endif]避免死鎖(銀行家算法)

[if !supportLists]3.?[endif]檢測死鎖(資源分配圖)

[if !supportLists]4.?[endif]解除死鎖

[if !supportLists]1.?[endif]剝奪資源

[if !supportLists]2.?[endif]撤銷進(jìn)程

4 程序編譯與鏈接

Bulid過程可以分解為4個步驟:預(yù)處理(Prepressing), 編譯(Compilation)、匯編(Assembly)恕稠、鏈接(Linking)

以c語言為例:

1 預(yù)處理

預(yù)編譯過程主要處理那些源文件中的以“#”開始的預(yù)編譯指令琅绅，主要處理規(guī)則有：

[if !supportLists]1.?[endif]將所有的“#define”刪除，并展開所用的宏定義

[if !supportLists]2.?[endif]處理所有條件預(yù)編譯指令鹅巍，比如“#if”千扶、“#ifdef”、 “#elif”骆捧、“#endif”

[if !supportLists]3.?[endif]處理“#include”預(yù)編譯指令澎羞，將被包含的文件插入到該編譯指令的位置，注：此過程是遞歸進(jìn)行的

[if !supportLists]4.?[endif]刪除所有注釋

[if !supportLists]5.?[endif]添加行號和文件名標(biāo)識敛苇，以便于編譯時編譯器產(chǎn)生調(diào)試用的行號信息以及用于編譯時產(chǎn)生編譯錯誤或警告時可顯示行號

[if !supportLists]6.?[endif]保留所有的#pragma編譯器指令妆绞。

2 編譯

編譯過程就是把預(yù)處理完的文件進(jìn)行一系列的詞法分析、語法分析枫攀、語義分析及優(yōu)化后生成相應(yīng)的匯編代碼文件括饶。這個過程是整個程序構(gòu)建的核心部分。

3 匯編

匯編器是將匯編代碼轉(zhuǎn)化成機器可以執(zhí)行的指令来涨，每一條匯編語句幾乎都是一條機器指令图焰。經(jīng)過編譯、鏈接蹦掐、匯編輸出的文件成為目標(biāo)文件(Object File)

4 鏈接

鏈接的主要內(nèi)容就是把各個模塊之間相互引用的部分處理好技羔，使各個模塊可以正確的拼接驰徊。鏈接的主要過程包塊地址和空間的分配（Address and Storage Allocation）、符號決議(Symbol Resolution)和重定位(Relocation)等步驟堕阔。

5 靜態(tài)鏈接和動態(tài)鏈接

靜態(tài)鏈接方法：靜態(tài)鏈接的時候棍厂，載入代碼就會把程序會用到的動態(tài)代碼或動態(tài)代碼的地址確定下來靜態(tài)庫的鏈接可以使用靜態(tài)鏈接，動態(tài)鏈接庫也可以使用這種方法鏈接導(dǎo)入庫

動態(tài)鏈接方法：使用這種方式的程序并不在一開始就完成動態(tài)鏈接超陆，而是直到真正調(diào)用動態(tài)庫代碼時牺弹，載入程序才計算(被調(diào)用的那部分)動態(tài)代碼的邏輯地址，然后等到某個時候时呀，程序又需要調(diào)用另外某塊動態(tài)代碼時张漂，載入程序又去計算這部分代碼的邏輯地址，所以谨娜，這種方式使程序初始化時間較短航攒，但運行期間的性能比不上靜態(tài)鏈接的程序

6 虛擬內(nèi)存技術(shù)

虛擬存儲器是值具有請求調(diào)入功能和置換功能,能從邏輯上對內(nèi)存容量加以擴充的一種存儲系統(tǒng).

7 分頁和分段

分頁: 用戶程序的地址空間被劃分成若干固定大小的區(qū)域，稱為“頁”趴梢，相應(yīng)地漠畜，內(nèi)存空間分成若干個物理塊，頁和塊的大小相等坞靶°灸可將用戶程序的任一頁放在內(nèi)存的任一塊中，實現(xiàn)了離散分配彰阴。

分段: 將用戶程序地址空間分成若干個大小不等的段瘾敢，每段可以定義一組相對完整的邏輯信息。存儲分配時尿这，以段為單位簇抵，段與段在內(nèi)存中可以不相鄰接，也實現(xiàn)了離散分配射众。

分頁與分段的主要區(qū)別

[if !supportLists]1.?[endif]頁是信息的物理單位,分頁是為了實現(xiàn)非連續(xù)分配,以便解決內(nèi)存碎片問題,或者說分頁是由于系統(tǒng)管理的需要.段是信息的邏輯單位,它含有一組意義相對完整的信息,分段的目的是為了更好地實現(xiàn)共享,滿足用戶的需要.

[if !supportLists]2.?[endif]頁的大小固定,由系統(tǒng)確定,將邏輯地址劃分為頁號和頁內(nèi)地址是由機器硬件實現(xiàn)的.而段的長度卻不固定,決定于用戶所編寫的程序,通常由編譯程序在對源程序進(jìn)行編譯時根據(jù)信息的性質(zhì)來劃分.

[if !supportLists]3.?[endif]分頁的作業(yè)地址空間是一維的.分段的地址空間是二維的.

8 頁面置換算法

[if !supportLists]1.?[endif]最佳置換算法OPT:不可能實現(xiàn)

[if !supportLists]2.?[endif]先進(jìn)先出FIFO

[if !supportLists]3.?[endif]最近最久未使用算法LRU:最近一段時間里最久沒有使用過的頁面予以置換.

[if !supportLists]4.?[endif]clock算法

9 邊沿觸發(fā)和水平觸發(fā)

邊緣觸發(fā)是指每當(dāng)狀態(tài)變化時發(fā)生一個io 事件碟摆，條件觸發(fā)是只要滿足條件就發(fā)生一個 io 事件

數(shù)據(jù)庫

1 事務(wù)

數(shù)據(jù)庫事務(wù)(Database Transaction) ，是指作為單個邏輯工作單元執(zhí)行的一系列操作责球，要么完全地執(zhí)行焦履，要么完全地不執(zhí)行职烧。

2 數(shù)據(jù)庫索引

索引是對數(shù)據(jù)庫表中一列或多列的值進(jìn)行排序的一種結(jié)構(gòu)嫂便，使用索引可快速訪問數(shù)據(jù)庫表中的特定信息聊疲。

索引分為聚簇索引和非聚簇索引兩種拉庶，聚簇索引是按照數(shù)據(jù)存放的物理位置為順序的缅叠，而非聚簇索引就不一樣了唧喉；聚簇索引能提高多行檢索的速度困檩，而非聚簇索引對于單行的檢索很快绳锅。

推薦: http://tech.meituan.com/mysql-index.html

3 Redis原理

4 樂觀鎖和悲觀鎖

悲觀鎖：假定會發(fā)生并發(fā)沖突仇让，屏蔽一切可能違反數(shù)據(jù)完整性的操作

樂觀鎖：假設(shè)不會發(fā)生并發(fā)沖突典奉，只在提交操作時檢查是否違反數(shù)據(jù)完整性躺翻。

5 MVCC

大多數(shù)的MySQL事務(wù)型存儲引擎，如InnoDB卫玖，F(xiàn)alcon以及PBXT都不使用一種簡單的行鎖機制公你。事實上，他們都和另外一種用來增加并發(fā)性的被稱為“多版本并發(fā)控制（MVCC）”的機制來一起使用假瞬。MVCC不只使用在MySQL中陕靠，Oracle、PostgreSQL脱茉，以及其他一些數(shù)據(jù)庫系統(tǒng)也同樣使用它剪芥。

6 MyISAM和InnoDB

MyISAM 適合于一些需要大量查詢的應(yīng)用，但其對于有大量寫操作并不是很好琴许。甚至你只是需要update一個字段税肪，整個表都會被鎖起來，而別的進(jìn)程榜田，就算是讀進(jìn)程都無法操作直到讀操作完成益兄。另外，MyISAM 對于 SELECT COUNT(*) 這類的計算是超快無比的串慰。

InnoDB 的趨勢會是一個非常復(fù)雜的存儲引擎偏塞，對于一些小的應(yīng)用，它會比 MyISAM 還慢邦鲫。他是它支持“行鎖” ，于是在寫操作比較多的時候神汹，會更優(yōu)秀庆捺。并且，他還支持更多的高級應(yīng)用屁魏，比如：事務(wù)滔以。

網(wǎng)絡(luò)

1 三次握手

[if !supportLists]1.?[endif]客戶端通過向服務(wù)器端發(fā)送一個SYN來創(chuàng)建一個主動打開，作為三路握手的一部分氓拼∧慊客戶端把這段連接的序號設(shè)定為隨機數(shù) A。

[if !supportLists]2.?[endif]服務(wù)器端應(yīng)當(dāng)為一個合法的SYN回送一個SYN/ACK桃漾。ACK 的確認(rèn)碼應(yīng)為 A+1坏匪，SYN/ACK 包本身又有一個隨機序號 B。

[if !supportLists]3.?[endif]最后撬统，客戶端再發(fā)送一個ACK适滓。當(dāng)服務(wù)端受到這個ACK的時候，就完成了三路握手恋追，并進(jìn)入了連接創(chuàng)建狀態(tài)凭迹。此時包序號被設(shè)定為收到的確認(rèn)號 A+1罚屋，而響應(yīng)則為 B+1。

2 四次揮手

CP的連接的拆除需要發(fā)送四個包嗅绸，因此稱為四次揮手(four-way handshake)脾猛。客戶端或服務(wù)器均可主動發(fā)起揮手動作鱼鸠，在socket編程中尖滚，任何一方執(zhí)行close()操作即可產(chǎn)生揮手操作。

（1）客戶端A發(fā)送一個FIN瞧柔，用來關(guān)閉客戶A到服務(wù)器B的數(shù)據(jù)傳送漆弄。

（2）服務(wù)器B收到這個FIN，它發(fā)回一個ACK造锅，確認(rèn)序號為收到的序號加1撼唾。和SYN一樣，一個FIN將占用一個序號哥蔚。

（3）服務(wù)器B關(guān)閉與客戶端A的連接倒谷，發(fā)送一個FIN給客戶端A。

（4）客戶端A發(fā)回ACK報文確認(rèn)糙箍，并將確認(rèn)序號設(shè)置為收到序號加1渤愁。

3 ARP協(xié)議

地址解析協(xié)議(Address Resolution Protocol): 根據(jù)IP地址獲取物理地址的一個TCP/IP協(xié)議

4 urllib和urllib2的區(qū)別

這個面試官確實問過,當(dāng)時答的urllib2可以Post而urllib不可以.

[if !supportLists]1.?[endif]urllib提供urlencode方法用來GET查詢字符串的產(chǎn)生，而urllib2沒有深夯。這是為何urllib常和urllib2一起使用的原因抖格。

[if !supportLists]2.?[endif]urllib2可以接受一個Request類的實例來設(shè)置URL請求的headers，urllib僅可以接受URL咕晋。這意味著雹拄，你不可以偽裝你的User Agent字符串等。

5 Post和Get區(qū)別

GET后退按鈕/刷新無害掌呜，POST數(shù)據(jù)會被重新提交（瀏覽器應(yīng)該告知用戶數(shù)據(jù)會被重新提交）滓玖。

GET書簽可收藏，POST為書簽不可收藏质蕉。

GET能被緩存势篡，POST不能緩存 。

GET編碼類型application/x-www-form-url模暗，POST編碼類型encodedapplication/x-www-form-urlencoded 或 multipart/form-data禁悠。為二進(jìn)制數(shù)據(jù)使用多重編碼。

GET歷史參數(shù)保留在瀏覽器歷史中汰蓉。POST參數(shù)不會保存在瀏覽器歷史中绷蹲。

GET對數(shù)據(jù)長度有限制，當(dāng)發(fā)送數(shù)據(jù)時，GET 方法向 URL 添加數(shù)據(jù)祝钢；URL 的長度是受限制的（URL 的最大長度是 2048 個字符）比规。POST無限制。

GET只允許 ASCII 字符拦英。POST沒有限制蜒什。也允許二進(jìn)制數(shù)據(jù)。

與POST 相比疤估，GET 的安全性較差灾常，因為所發(fā)送的數(shù)據(jù)是 URL 的一部分。在發(fā)送密碼或其他敏感信息時絕不要使用 GET 铃拇！POST 比 GET 更安全钞瀑，因為參數(shù)不會被保存在瀏覽器歷史或 web 服務(wù)器日志中。

GET的數(shù)據(jù)在 URL 中對所有人都是可見的慷荔。POST的數(shù)據(jù)不會顯示在 URL 中雕什。

6 Cookie和Session

?CookieSession

儲存位置客戶端服務(wù)器端

目的跟蹤會話，也可以保存用戶偏好設(shè)置或者保存用戶名密碼等跟蹤會話

安全性不安全安全

session技術(shù)是要使用到cookie的显晶，之所以出現(xiàn)session技術(shù)贷岸，主要是為了安全。

7 apache和nginx的區(qū)別

nginx 相對 apache 的優(yōu)點：

[if !supportLists]·?[endif]輕量級磷雇，同樣起web 服務(wù)偿警，比apache 占用更少的內(nèi)存及資源

[if !supportLists]·?[endif]抗并發(fā)，nginx 處理請求是異步非阻塞的唯笙，支持更多的并發(fā)連接螟蒸，而apache 則是阻塞型的，在高并發(fā)下nginx 能保持低資源低消耗高性能

[if !supportLists]·?[endif]配置簡潔

[if !supportLists]·?[endif]高度模塊化的設(shè)計睁本，編寫模塊相對簡單

[if !supportLists]·?[endif]社區(qū)活躍

apache 相對nginx 的優(yōu)點：

[if !supportLists]·?[endif]rewrite 尿庐，比nginx 的rewrite 強大

[if !supportLists]·?[endif]模塊超多，基本想到的都可以找到

[if !supportLists]·?[endif]少bug 呢堰，nginx 的bug 相對較多

[if !supportLists]·?[endif]超穩(wěn)定

8 網(wǎng)站用戶密碼保存

[if !supportLists]1.?[endif]明文保存

[if !supportLists]2.?[endif]明文hash后保存,如md5

[if !supportLists]3.?[endif]MD5+Salt方式,這個salt可以隨機

[if !supportLists]4.?[endif]知乎使用了Bcrypy(好像)加密

9 HTTP和HTTPS

HTTPS（全稱：Hypertext Transfer Protocol over Secure Socket Layer），是以安全為目標(biāo)的HTTP通道凡泣，簡單講是HTTP的安全版枉疼。即HTTP下加入SSL層，HTTPS的安全基礎(chǔ)是SSL鞋拟，因此加密的詳細(xì)內(nèi)容就需要SSL骂维。 它是一個URI scheme（抽象標(biāo)識符體系），句法類同http:體系贺纲。用于安全的HTTP數(shù)據(jù)傳輸航闺。https:URL表明它使用了HTTP，但HTTPS存在不同于HTTP的默認(rèn)端口及一個加密/身份驗證層（在HTTP與TCP之間）。這個系統(tǒng)的最初研發(fā)由網(wǎng)景公司進(jìn)行潦刃，提供了身份驗證與加密通訊方法侮措，現(xiàn)在它被廣泛用于萬維網(wǎng)上安全敏感的通訊，例如交易支付方面乖杠。

超文本傳輸協(xié)議(HTTP-Hypertext transfer protocol) 是一種詳細(xì)規(guī)定了瀏覽器和萬維網(wǎng)服務(wù)器之間互相通信的規(guī)則分扎，通過因特網(wǎng)傳送萬維網(wǎng)文檔的數(shù)據(jù)傳送協(xié)議。

10 XSRF和XSS

[if !supportLists]·?[endif]CSRF(Cross-site request forgery)跨站請求偽造

[if !supportLists]·?[endif]XSS(Cross Site Scripting)跨站腳本攻擊

CSRF重點在請求,XSS重點在腳本

11 RESTful架構(gòu)(SOAP,RPC)

推薦: http://www.ruanyifeng.com/blog/2011/09/restful.html

12 SOAP

SOAP（原為Simple Object Access Protocol的首字母縮寫胧洒，即簡單對象訪問協(xié)議）是交換數(shù)據(jù)的一種協(xié)議規(guī)范畏吓，使用在計算機網(wǎng)絡(luò)Web服務(wù)（web service）中，交換帶結(jié)構(gòu)信息卫漫。SOAP為了簡化網(wǎng)頁服務(wù)器（Web Server）從XML數(shù)據(jù)庫中提取數(shù)據(jù)時菲饼，節(jié)省去格式化頁面時間，以及不同應(yīng)用程序之間按照HTTP通信協(xié)議列赎，遵從XML格式執(zhí)行資料互換宏悦，使其抽象于語言實現(xiàn)、平臺和硬件粥谬。

13 RPC

RPC（Remote Procedure Call Protocol）——遠(yuǎn)程過程調(diào)用協(xié)議肛根，它是一種通過網(wǎng)絡(luò)從遠(yuǎn)程計算機程序上請求服務(wù)，而不需要了解底層網(wǎng)絡(luò)技術(shù)的協(xié)議漏策。RPC協(xié)議假定某些傳輸協(xié)議的存在派哲，如TCP或UDP，為通信程序之間攜帶信息數(shù)據(jù)掺喻。在OSI網(wǎng)絡(luò)通信模型中芭届，RPC跨越了傳輸層和應(yīng)用層。RPC使得開發(fā)包括網(wǎng)絡(luò)分布式多程序在內(nèi)的應(yīng)用程序更加容易感耙。

總結(jié):服務(wù)提供的兩大流派.傳統(tǒng)意義以方法調(diào)用為導(dǎo)向通稱RPC褂乍。為了企業(yè)SOA,若干廠商聯(lián)合推出webservice,制定了wsdl接口定義,傳輸soap.當(dāng)互聯(lián)網(wǎng)時代,臃腫SOA被簡化為http+xml/json.但是簡化出現(xiàn)各種混亂。以資源為導(dǎo)向,任何操作無非是對資源的增刪改查即硼，于是統(tǒng)一的REST出現(xiàn)了.

進(jìn)化的順序: RPC -> SOAP -> RESTful

14 CGI和WSGI

CGI是通用網(wǎng)關(guān)接口逃片，是連接web服務(wù)器和應(yīng)用程序的接口，用戶通過CGI來獲取動態(tài)數(shù)據(jù)或文件等只酥。CGI程序是一個獨立的程序褥实，它可以用幾乎所有語言來寫，包括perl裂允，c损离，lua，python等等绝编。

WSGI, Web Server Gateway Interface僻澎，是Python應(yīng)用程序或框架和Web服務(wù)器之間的一種接口貌踏，WSGI的其中一個目的就是讓用戶可以用統(tǒng)一的語言(Python)編寫前后端。

16 中間人攻擊

在GFW里屢見不鮮的,呵呵.

中間人攻擊（Man-in-the-middle attack窟勃，通匙嫒椋縮寫為MITM）是指攻擊者與通訊的兩端分別創(chuàng)建獨立的聯(lián)系，并交換其所收到的數(shù)據(jù)拳恋，使通訊的兩端認(rèn)為他們正在通過一個私密的連接與對方直接對話凡资，但事實上整個會話都被攻擊者完全控制。

17 c10k問題

所謂c10k問題谬运，指的是服務(wù)器同時支持成千上萬個客戶端的問題隙赁，也就是concurrent 10 000 connection（這也是c10k這個名字的由來）。

18 socket

Socket=Ip address+ TCP/UDP + port

19 瀏覽器緩存

推薦:http://web.jobbole.com/84367/

瀏覽器緩存機制梆暖，其實主要就是HTTP協(xié)議定義的緩存機制（如： Expires伞访； Cache-control等）

Expires策略

Expires是Web服務(wù)器響應(yīng)消息頭字段，在響應(yīng)http請求時告訴瀏覽器在過期時間前瀏覽器可以直接從瀏覽器緩存取數(shù)據(jù)轰驳，而無需再次請求厚掷。

Cache-control策略（重點關(guān)注）

Cache-Control與Expires的作用一致，都是指明當(dāng)前資源的有效期级解，控制瀏覽器是否直接從瀏覽器緩存取數(shù)據(jù)還是重新發(fā)請求到服務(wù)器取數(shù)據(jù)冒黑。只不過Cache-Control的選擇更多，設(shè)置更細(xì)致勤哗，如果同時設(shè)置的話抡爹，其優(yōu)先級高于Expires?

20 HTTP1.0和HTTP1.1

推薦: http://blog.csdn.net/elifefly/article/details/3964766

[if !supportLists]1.?[endif]請求頭Host字段,一個服務(wù)器多個網(wǎng)站

[if !supportLists]2.?[endif]長鏈接

[if !supportLists]3.?[endif]文件斷點續(xù)傳

[if !supportLists]4.?[endif]身份認(rèn)證,狀態(tài)管理,Cache緩存

21 Ajax

AJAX,Asynchronous JavaScript and XML（異步的 JavaScript 和 XML）, 是與在不重新加載整個頁面的情況下，與服務(wù)器交換數(shù)據(jù)并更新部分網(wǎng)頁的技術(shù)芒划。

數(shù)據(jù)結(jié)構(gòu)

1 紅黑樹

紅黑樹與AVL的比較：

AVL是嚴(yán)格平衡樹冬竟，因此在增加或者刪除節(jié)點的時候，根據(jù)不同情況民逼，旋轉(zhuǎn)的次數(shù)比紅黑樹要多泵殴；

紅黑是用非嚴(yán)格的平衡來換取增刪節(jié)點時候旋轉(zhuǎn)次數(shù)的降低；

所以簡單說拼苍，如果你的應(yīng)用中伊磺，搜索的次數(shù)遠(yuǎn)遠(yuǎn)大于插入和刪除社付，那么選擇AVL淑玫，如果搜索袱讹，插入刪除次數(shù)幾乎差不多，應(yīng)該選擇RB棚点。

1 臺階問題/斐波納挈

一只青蛙一次可以跳上1級臺階，也可以跳上2級湾蔓。求該青蛙跳上一個n級的臺階總共有多少種跳法瘫析。

1fib?=?lambda?n:?n?if?n?<=?2?else?fib(n?-?1)?+?fib(n?-?2)

第二種記憶方法

?def?memo(func):

????cache?=?{}

????def?wrap(*args):

????????if?args not?in?cache:

????????????cache[args]?=?func(*args)

????????return?cache[args]

????return?wrap

@?memo

def?fib(i):

????if?i?<?2:

????????return?1

????return?fib(i-1)?+?fib(i-2)

第三種方法

def?fib(n):

????a,?b?=?0,?1

????for?_?in?xrange(n):

????????a,?b?=?b,?a?+?b

????return?b

2 變態(tài)臺階問題

一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法贬循。

1fib?=?lambda?n:?n?if?n?<?2?else?2?*?fib(n?-?1)

3 矩形覆蓋

我們可以用2*1的小矩形橫著或者豎著去覆蓋更大的矩形咸包。請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法杖虾？

第2*n個矩形的覆蓋方法等于第2*(n-1)加上第2*(n-2)的方法烂瘫。

1f?=?lambda?n:?1?if?n?<?2?else?f(n?-?1)?+?f(n?-?2)

4 楊氏矩陣查找

在一個m行n列二維數(shù)組中，每一行都按照從左到右遞增的順序排序奇适，每一列都按照從上到下遞增的順序排序坟比。請完成一個函數(shù)，輸入這樣的一個二維數(shù)組和一個整數(shù)嚷往，判斷數(shù)組中是否含有該整數(shù)葛账。

5 去除列表中的重復(fù)元素

用集合

1list(set(l))

用字典

l1?=?['b','c','d','b','c','a','a']

l2?=?{}.fromkeys(l1).keys()

print?l2

用字典并保持順序

l1?=?['b','c','d','b','c','a','a']

l2?=?list(set(l1))

l2.sort(key=l1.index)

print?l2

l1?=?['b','c','d','b','c','a','a']

l2?=?[]

[l2.append(i)?for?i?in?l1 if?not?i?in?l2]

面試官提到的,先排序然后刪除.

6 鏈表成對調(diào)換

1->2->3->4轉(zhuǎn)換成2->1->4->3.

?class?ListNode:

????def?__init__(self,?x):

????????self.val?=?x

????????self.next?=?None

class?Solution:

????# @param a ListNode

????# @return a ListNode

????def?swapPairs(self,?head):

????????if?head?!=?None?and?head.next?!=?None:

????????????next?=?head.next

????????????head.next?=?self.swapPairs(next.next)

????????????next.next?=?head

????????????return?next

????????return?head

7 創(chuàng)建字典的方法

1 直接創(chuàng)建

1dict?=?{'name':'earth',?'port':'80'}

2 工廠方法

items=[('name','earth'),('port','80')]

dict2=dict(items)

dict1=dict((['name','earth'],['port','80']))

3 fromkeys()方法

dict1={}.fromkeys(('x','y'),-1)

dict={'x':-1,'y':-1}

dict2={}.fromkeys(('x','y'))

dict2={'x':None,?'y':None}

8 合并兩個有序列表

知乎遠(yuǎn)程面試要求編程

尾遞歸

?def?_recursion_merge_sort2(l1,?l2,?tmp):

????if?len(l1)?==?0?or?len(l2)?==?0:

????????tmp.extend(l1)

????????tmp.extend(l2)

????????return?tmp

????else:

????????if?l1[0]?<?l2[0]:

????????????tmp.append(l1[0])

????????????del?l1[0]

????????else:

????????????tmp.append(l2[0])

????????????del?l2[0]

????????return?_recursion_merge_sort2(l1,?l2,?tmp)

def?recursion_merge_sort2(l1,?l2):

????return?_recursion_merge_sort2(l1,?l2,?[])

循環(huán)算法

?def?loop_merge_sort(l1,?l2):

????tmp?=?[]

????while?len(l1)?>?0?and?len(l2)?>?0:

????????if?l1[0]?<?l2[0]:

????????????tmp.append(l1[0])

????????????del?l1[0]

????????else:

????????????tmp.append(l2[0])

????????????del?l2[0]

????tmp.extend(l1)

????tmp.extend(l2)

????return?tmp

9 交叉鏈表求交點

去哪兒的面試,沒做出來.

?class?ListNode:

????def?__init__(self,?x):

????????self.val?=?x

????????self.next?=?None

def?node(l1,?l2):

????length1,?lenth2?=?0,?0

????#求兩個鏈表長度

????while?l1.next:

????????l1?=?l1.next

????????length1?+=?1

????while?l2.next:

????????l2?=?l2.next

????????length2?+=?1

????#長的鏈表先走

????if?length1?>?lenth2:

????????for?_?in?range(length1?-?length2):

????????????l1?=?l1.next

????else:

????????for?_?in?range(length2?-?length1):

????????????l2?=?l2.next

????while?l1 and?l2:

????????if?l1.next?==?l2.next:

????????????return?l1.next

????????else:

????????????l1?=?l1.next

????????????l2?=?l2.next

10 二分查找

?def?binarySearch(l,?t):

????low,?high?=?0,?len(l)?-?1

????while?low?<?high:

????????print?low,?high

????????mid?=?(low?+?high)?/?2

????????if?l[mid]?>?t:

????????????high?=?mid

????????elif?l[mid]?<?t:

????????????low?=?mid?+?1

????????else:

????????????return?mid

????return?low if?l[low]?==?t?else?False

if?__name__?==?'__main__':

????l?=?[1,?4,?12,?45,?66,?99,?120,?444]

????print?binarySearch(l,?12)

????print?binarySearch(l,?1)

????print?binarySearch(l,?13)

????print?binarySearch(l,?444)

11 快排

def?qsort(seq):

????if?seq==[]:

????????return?[]

????else:

????????pivot=seq[0]

????????lesser=qsort([x?for?x?in?seq[1:]?if?x

????????greater=qsort([x?for?x?in?seq[1:]?if?x>=pivot])

????????return?lesser+[pivot]+greater

if?__name__=='__main__':

????seq=[5,6,78,9,0,-1,2,3,-65,12]

????print(qsort(seq))

12 找零問題

?def??coinChange(values,?money,?coinsUsed):

????#values????T[1:n]數(shù)組

????#valuesCounts錢幣對應(yīng)的種類數(shù)

????#money找出來的總錢數(shù)

????#coinsUsed對應(yīng)于目前錢幣總數(shù)i所使用的硬幣數(shù)目

????for?cents in?range(1,?money+1):

????????minCoins?=?cents???? #從第一個開始到money的所有情況初始

????????for?value in?values:

????????????if?value?<=?cents:

????????????????temp?=?coinsUsed[cents?-?value]?+?1

????????????????if?temp?<?minCoins:

????????????????????minCoins?=?temp

????????coinsUsed[cents]?=?minCoins

????????print('面值為：{0} 的最小硬幣數(shù)目為：{1} '.format(cents,?coinsUsed[cents])?)

if?__name__?==?'__main__':

????values?=?[?25,?21,?10,?5,?1]

????money?=?63

????coinsUsed?=?{i:0?for?i?in?range(money+1)}

????coinChange(values,?money,?coinsUsed)

13 廣度遍歷和深度遍歷二叉樹

給定一個數(shù)組，構(gòu)建二叉樹皮仁，并且按層次打印這個二叉樹

?## 14二叉樹節(jié)點

class?Node(object):

????def?__init__(self,?data,?left=None,?right=None):

????????self.data?=?data

????????self.left?=?left

????????self.right?=?right

tree?=?Node(1,?Node(3,?Node(7,?Node(0)),?Node(6)),?Node(2,?Node(5),?Node(4)))

## 15層次遍歷

def?lookup(root):

????stack?=?[root]

????while?stack:

????????current?=?stack.pop(0)

????????print?current.data

????????if?current.left:

????????????stack.append(current.left)

????????if?current.right:

????????????stack.append(current.right)

## 16深度遍歷

def?deep(root):

????if?not?root:

????????return

????print?root.data

????deep(root.left)

????deep(root.right)

if?__name__?==?'__main__':

????lookup(tree)

????deep(tree)

17 前中后序遍歷

深度遍歷改變順序就OK了

18 求最大樹深

def?maxDepth(root):

????????if?not?root:

????????????return?0

????????return?max(maxDepth(root.left),?maxDepth(root.right))?+?1

19 求兩棵樹是否相同

def?isSameTree(p,?q):

????if?p?==?None?and?q?==?None:

????????return?True

????elif?p?and?q?:

????????return?p.val?==?q.val and?isSameTree(p.left,q.left)?and?isSameTree(p.right,q.right)

????else?:

????????return?False

20 前序中序求后序

?def?rebuild(pre,?center):

????if?not?pre:

????????return

????cur?=?Node(pre[0])

????index?=?center.index(pre[0])

????cur.left?=?rebuild(pre[1:index?+?1],?center[:index])

????cur.right?=?rebuild(pre[index?+?1:],?center[index?+?1:])

????return?cur

def?deep(root):

????if?not?root:

????????return

????deep(root.left)

????deep(root.right)

????print?root.data

21 單鏈表逆置

?class?Node(object):

????def?__init__(self,?data=None,?next=None):

????????self.data?=?data

????????self.next?=?next

link?=?Node(1,?Node(2,?Node(3,?Node(4,?Node(5,?Node(6,?Node(7,?Node(8,?Node(9)))))))))

def?rev(link):

????pre?=?link

????cur?=?link.next

????pre.next?=?None

????while?cur:

????????tmp?=?cur.next

????????cur.next?=?pre

????????pre?=?cur

????????cur?=?tmp

????return?pre

root?=?rev(link)

while?root:

????print?root.data

????root?=?root.next

Python Web相關(guān)

解釋一下WSGI和 FastCGI 的關(guān)系籍琳？

CGI全稱是“公共網(wǎng)關(guān)接口”(CommonGateway Interface)，HTTP服務(wù)器與你的或其它機器上的程序進(jìn)行“交談”的一種工具贷祈，其程序須運行在網(wǎng)絡(luò)服務(wù)器上趋急。　CGI可以用任何一種語言編寫势誊，只要這種語言具有標(biāo)準(zhǔn)輸入呜达、輸出和環(huán)境變量。如php,perl,tcl等键科。

FastCGI像是一個常駐(long-live)型的CGI闻丑，它可以一直執(zhí)行著，只要激活后勋颖，不會每次都要花費時間去fork一次(這是CGI最為人詬病的fork-and-execute模式)嗦嗡。它還支持分布式的運算, 即 FastCGI 程序可以在網(wǎng)站服務(wù)器以外的主機上執(zhí)行并且接受來自其它網(wǎng)站服務(wù)器來的請求。

FastCGI是語言無關(guān)的饭玲、可伸縮架構(gòu)的CGI開放擴展侥祭，其主要行為是將CGI解釋器進(jìn)程保持在內(nèi)存中并因此獲得較高的性能。眾所周知茄厘，CGI解釋器的反復(fù)加載是CGI性能低下的主要原因矮冬，如果CGI解釋器保持在內(nèi)存中并接受FastCGI進(jìn)程管理器調(diào)度，則可以提供良好的性能次哈、伸縮性胎署、Fail- Over特性等等。

WSGI的全稱為：PythonWeb Server Gateway Interface v1.0 （Python Web 服務(wù)器網(wǎng)關(guān)接口）窑滞，

它是Python 應(yīng)用程序和 WEB 服務(wù)器之間的一種接口琼牧。

它的作用恢筝，類似于FCGI 或 FASTCGI 之類的協(xié)議的作用。

WSGI 的目標(biāo)巨坊，是要建立一個簡單的普遍適用的服務(wù)器與 WEB 框架之間的接口撬槽。

Flup就是使用Python 語言對 WSGI 的一種實現(xiàn)，是可以用于 Python 的應(yīng)用開發(fā)中的一種工具或者說是一種庫趾撵。

Spawn-fcgi是一個小程序侄柔，這個程序的作用是管理fast-cgi進(jìn)程，那么管理wsgi進(jìn)程也是沒有問題的占调，功能和php-fpm類似暂题。

故，簡單地說妈候，WSGI和FastCGI都是一種CGI敢靡，用于連接WEB服務(wù)器與應(yīng)用程序，而WSGI專指Python應(yīng)用程序苦银。而flup是WSGI的一種實現(xiàn)啸胧，Spawn-fcgi是用于管理flup進(jìn)程的一個工具，可以啟動多個wsgi進(jìn)程幔虏，并管理它們纺念。

解釋一下Django 和 Tornado 的關(guān)系、差別

Django源自一個在線新聞Web站點想括，于 2005 年以開源的形式被釋放出來陷谱。

Django 框架的核心組件有：

用于創(chuàng)建模型的對象關(guān)系映射為最終用戶設(shè)計的完美管理界面一流的URL 設(shè)計設(shè)計者友好的模板語言緩存系統(tǒng)等等

它鼓勵快速開發(fā),并遵循MVC設(shè)計。Django遵守 BSD版權(quán)瑟蜈，最新發(fā)行版本是Django

1.4烟逊，于2012年03月23日發(fā)布.Django的主要目的是簡便、快速的開發(fā)數(shù)據(jù)庫驅(qū)動的網(wǎng)站铺根。它強調(diào)代碼復(fù)用,多個組件可以很方便的以“插件”形式服務(wù)于整個框架宪躯，Django有許多功能強大的第三方插件，你甚至可以很方便的開發(fā)出自己的工具包位迂。這使得Django具有很強的可擴展性访雪。它還強調(diào)快速開發(fā)和DRY(Do Not RepeatYourself)原則。

Tornado是FriendFeed使用的可擴展的非阻塞式 web 服務(wù)器及其相關(guān)工具的開源版本掂林。這個 Web 框架看起來有些像 web.py 或者 Google 的 webapp臣缀，不過為了能有效利用非阻塞式服務(wù)器環(huán)境，這個 Web 框架還包含了一些相關(guān)的有用工具和優(yōu)化泻帮。

Tornado 和現(xiàn)在的主流 Web 服務(wù)器框架（包括大多數(shù)Python 的框架）有著明顯的區(qū)別：它是非阻塞式服務(wù)器精置，而且速度相當(dāng)快。得利于其 非阻塞的方式和對epoll的運用锣杂，Tornado 每秒可以處理數(shù)以千計的連接氯窍，這意味著對于實時 Web服務(wù)來說饲常，Tornado 是一個理想的 Web 框架。我們開發(fā)這個 Web 服務(wù)器的主要目的就是為了處理 FriendFeed 的實時功能 ——在 FriendFeed 的應(yīng)用里每一個活動用戶都會保持著一個服務(wù)器連接狼讨。（關(guān)于如何擴容 服務(wù)器，以處理數(shù)以千計的客戶端的連接的問題柒竞。

解釋下django-debug-toolbar的使用

使用django開發(fā)站點時政供，可以使用django-debug-toolbar來進(jìn)行調(diào)試。在settings.py中添加’debug_toolbar.middleware.DebugToolbarMiddleware’到項目的MIDDLEWARE_CLASSES 內(nèi)朽基。

解釋下Django使用redis緩存服務(wù)器

為了能在Django中使用redis布隔，還需要安裝redis for Django的插件。然后在Django的settings中配置了〖诨ⅲ現(xiàn)在連接和配置都已經(jīng)完成了衅檀，接下來是一個簡單的例子：

?from django.conf import settings

from django.core.cache import cache

#read cache user id

def read_from_cache(self,?user_name):

????key?=?'user_id_of_'+user_name

????value?=?cache.get(key)

????if?value?==?None:

????????data?=?None

????else:

????????data?=?json.loads(value)

????return?data

#write cache user id

def write_to_cache(self,?user_name):

????key?=?'user_id_of_'+user_name

????cache.set(key,?json.dumps(user_name),?settings.NEVER_REDIS_TIMEOUT)

如何進(jìn)行Django單元測試

Django的單元測試使用python的unittest模塊，這個模塊使用基于類的方法來定義測試霎俩。類名為django.test.TestCase,繼承于python的unittest.TestCase哀军。

?from django.test import TestCase

from myapp.models import Animal

class?AnimalTestCase(TestCase):

????def setUp(self):

????????Animal.objects.create(name="lion",?sound="roar")

????????Animal.objects.create(name="cat",?sound="meow")

????def test_animals_can_speak(self):

????????"""Animals that can speak are correctly identified"""

????????lion?=?Animal.objects.get(name="lion")

????????cat?=?Animal.objects.get(name="cat")

????????self.assertEqual(lion.speak(),?'The lion says "roar"')

????????self.assertEqual(cat.speak(),?'The cat says "meow"')

執(zhí)行目錄下所有的測試(所有的test*.py文件)：運行測試的時候，測試程序會在所有以test開頭的文件中查找所有的test cases(inittest.TestCase的子類),自動建立測試集然后運行測試打却。

1$?python manage.py test

執(zhí)行animals項目下tests包里的測試：

?$?python manage.py testanimals.tests

執(zhí)行animals項目里的test測試：

1$?python manage.py testanimals

單獨執(zhí)行某個test case：

1$?python manage.py testanimals.tests.AnimalTestCase

單獨執(zhí)行某個測試方法：

1$?python manage.py testanimals.tests.AnimalTestCase.test_animals_can_speak

為測試文件提供路徑：

1$?python manage.py testanimals/

通配測試文件名：

1$?python manage.py test--pattern="tests_*.py"

啟用warnings提醒：

1$?python?-Wall manage.py test

解釋下Http協(xié)議

HTTP是一個屬于應(yīng)用層的面向?qū)ο蟮膮f(xié)議杉适，由于其簡捷、快速的方式柳击，適用于分布式超媒體信息系統(tǒng)猿推。

HTTP協(xié)議的主要特點可概括如下：

1.支持客戶/服務(wù)器模式。

2.簡單快速：客戶向服務(wù)器請求服務(wù)時捌肴，只需傳送請求方法和路徑蹬叭。請求方法常用的有GET、HEAD状知、POST秽五。每種方法規(guī)定了客戶與服務(wù)器聯(lián)系的類型不同。由于HTTP協(xié)議簡單试幽，使得HTTP服務(wù)器的程序規(guī)模小筝蚕，因而通信速度很快。

3.靈活：HTTP允許傳輸任意類型的數(shù)據(jù)對象铺坞。正在傳輸?shù)念愋陀蒀ontent-Type加以標(biāo)記起宽。

4.無連接：無連接的含義是限制每次連接只處理一個請求。服務(wù)器處理完客戶的請求济榨，并收到客戶的應(yīng)答后坯沪，即斷開連接。采用這種方式可以節(jié)省傳輸時間擒滑。

5.無狀態(tài)：HTTP協(xié)議是無狀態(tài)協(xié)議腐晾。無狀態(tài)是指協(xié)議對于事務(wù)處理沒有記憶能力叉弦。缺少狀態(tài)意味著如果后續(xù)處理需要前面的信息，則它必須重傳藻糖，這樣可能導(dǎo)致每次連接傳送的數(shù)據(jù)量增大淹冰。另一方面，在服務(wù)器不需要先前信息時它的應(yīng)答就較快巨柒。

解釋下Http請求頭和常見響應(yīng)狀態(tài)碼

Accept:指瀏覽器或其他客戶可以接愛的MIME文件格式樱拴。可以根據(jù)它判斷并返回適當(dāng)?shù)奈募袷健?/p>

Accept-Charset：指出瀏覽器可以接受的字符編碼洋满。英文瀏覽器的默認(rèn)值是ISO-8859-1.

Accept-Language：指出瀏覽器可以接受的語言種類晶乔，如en或en-us，指英語牺勾。

Accept-Encoding：指出瀏覽器可以接受的編碼方式正罢。編碼方式不同于文件格式，它是為了壓縮文件并加速文件傳遞速度驻民。瀏覽器在接收到Web響應(yīng)之后先解碼翻具，然后再檢查文件格式。

Cache-Control：設(shè)置關(guān)于請求被代理服務(wù)器存儲的相關(guān)選項川无。一般用不到呛占。

Connection：用來告訴服務(wù)器是否可以維持固定的HTTP連接。HTTP/1.1使用Keep-Alive為默認(rèn)值懦趋，這樣晾虑，當(dāng)瀏覽器需要多個文件時(比如一個HTML文件和相關(guān)的圖形文件)，不需要每次都建立連接仅叫。

Content-Type：用來表名request的內(nèi)容類型帜篇。可以用HttpServletRequest的getContentType()方法取得诫咱。

Cookie：瀏覽器用這個屬性向服務(wù)器發(fā)送Cookie笙隙。Cookie是在瀏覽器中寄存的小型數(shù)據(jù)體，它可以記載和服務(wù)器相關(guān)的用戶信息坎缭，也可以用來實現(xiàn)會話功能竟痰。

狀態(tài)代碼有三位數(shù)字組成，第一個數(shù)字定義了響應(yīng)的類別掏呼，且有五種可能取值：

1xx：指示信息–表示請求已接收坏快，繼續(xù)處理

2xx：成功–表示請求已被成功接收、理解憎夷、接受

3xx：重定向–要完成請求必須進(jìn)行更進(jìn)一步的操作

4xx：客戶端錯誤–請求有語法錯誤或請求無法實現(xiàn)

5xx：服務(wù)器端錯誤–服務(wù)器未能實現(xiàn)合法的請求

常見狀態(tài)代碼莽鸿、狀態(tài)描述、說明：

200 OK?????//客戶端請求成功

400 Bad Request? //客戶端請求有語法錯誤，不能被服務(wù)器所理解

401 Unauthorized //請求未經(jīng)授權(quán)祥得，這個狀態(tài)代碼必須和WWW-Authenticate報頭域一起使用

403 Forbidden? //服務(wù)器收到請求兔沃，但是拒絕提供服務(wù)

404 Not Found? //請求資源不存在，eg：輸入了錯誤的URL

500 Internal Server Error //服務(wù)器發(fā)生不可預(yù)期的錯誤

503 Server Unavailable? //服務(wù)器當(dāng)前不能處理客戶端的請求级及，一段時間后可能恢復(fù)正常

eg：HTTP/1.1 200 OK （CRLF）

爬蟲

一乒疏、試列出至少三種目前流行的大型數(shù)據(jù)庫的名稱:________、_________创千、__________,其中您最熟悉的是__________,從__________年開始使用缰雇。

Oracle，Mysql追驴，SQLServer Oracle根據(jù)自己情況

二、有表List疏之，并有字段A殿雪、B、C锋爪，類型都是整數(shù)丙曙。表中有如下幾條記錄：

ABC

279

564

3119

現(xiàn)在對該表一次完成以下操作：

查詢出B和C列的值，要求按B列升序排列

寫出一條新的記錄其骄，值為{7,9,8}

查詢C列亏镰，要求消除重復(fù)的值，按降序排列

寫出完成完成以上操作的標(biāo)準(zhǔn)的SQL語句拯爽，并且寫出操作3的結(jié)果索抓。

create table List(A int,B int,C int)

Select B,C from List order by B

Insert into List values(7,9,8)

Select distinct(C) from List order by desc;

984

三、請簡要說明視圖的作用

1.數(shù)據(jù)庫視圖隱藏了數(shù)據(jù)的復(fù)雜性毯炮。

2.數(shù)據(jù)庫視圖有利于控制用戶對表中某些列的訪問逼肯。

3.數(shù)據(jù)庫視圖使用戶查詢變得簡單。

四桃煎、列舉您使用過的python網(wǎng)絡(luò)爬蟲所用到的網(wǎng)絡(luò)數(shù)據(jù)包（最熟悉的在前）：

requests篮幢、urllib、urllib2为迈、httplib2

五三椿、列舉您使用過的python網(wǎng)絡(luò)爬蟲所用到的解析數(shù)據(jù)包（最熟悉的在前）：

BeautifulSoup、pyquery葫辐、Xpath搜锰、lxml

六、列舉您使用過的python中的編碼方式（最熟悉的在前）：

UTF-8另患，ASCII纽乱，gbk

[if !supportLists]?[endif]

七、python3.5語言中enumerate的意思是_______________________

對于一個可迭代的（iterable）/可遍歷的對象（如列表昆箕、字符串）鸦列，enumerate將其組成一個索引序列租冠，利用它可以同時獲得索引和值

enumerate多用于在for循環(huán)中得到計數(shù)

八、99的八進(jìn)制表示是_______________________

143

九薯嗤、請舉出三種常用的排序算法

冒泡顽爹、選擇、快速

十骆姐、列出比較熟悉的爬蟲框架

Scrapy

十一兵拢、用4、9缝裤、2房蝉、7四個數(shù)字，可以使用+带射、-同规、*和/，每個數(shù)字使用一次窟社，使表達(dá)式的結(jié)果為24券勺，表達(dá)式是_____________________________

（9+7-4）*2

十二、對你最有影響的或是您認(rèn)為最有價值的軟件方面的幾本書是灿里？

十三关炼、您最熟悉的Unix環(huán)境是_____________.Unix下查詢環(huán)境變量的命令是________,查詢腳本定時任務(wù)的命令是____________________

1AIX，envcrontab

十四匣吊、寫出在網(wǎng)絡(luò)爬蟲爬取數(shù)據(jù)的過程中儒拂，遇到的防爬蟲問題的解決方案

通過headers反爬蟲：解決策略，偽造headers

基于用戶行為反爬蟲：動態(tài)變化去爬取數(shù)據(jù)缀去，模擬普通用戶的行為

基于動態(tài)頁面的反爬蟲：跟蹤服務(wù)器發(fā)送的ajax請求侣灶，模擬ajax請求

十五、閱讀以下Python程序

foriinrange(5,0,-1):

print(i)

請在下面寫出打印結(jié)果

54321

十六缕碎、在某系統(tǒng)中一個整數(shù)占用兩個八位字節(jié)褥影，使用Python按下面的要求編寫完整程序。

接收從標(biāo)準(zhǔn)輸入中依次輸入的五個數(shù)字咏雌，將其組合成為一個整數(shù)凡怎，放入全局變量n中，隨后在標(biāo)準(zhǔn)輸出輸出這個整數(shù)赊抖。（ord(char)獲取字符ASCII值的函數(shù)）

人统倒，從剛出生來到這個世界，便開始探索這個世界氛雪。累了就歇會房匆，精神了就繼續(xù)探索，直至死亡。