21. 1<(2==2) 和 1<2 == 2結(jié)果分別是什么？為什么？

1<(2==2) # False
1<2 ==2 # True
#解釋
1 ==True 為True
0 == False 為True
1<(2==2) 相當(dāng)于1<1 所以為錯誤
1<2 == 2 被分解成1<2 and 2==2 所以為True

詳情請見

運(yùn)算符

22. [i%2 for i in range(10)] 和 (i % 2 for i in range(10)) 輸出結(jié)果分別是什么？

[0,0,1,1,2,2,3,3,4,4]
一個生成器:<generator object <genexpr> at 0x1010aa620>

23.python2 和python3有哪些顯著的區(qū)別？

print

print在 Python 2 中是一個聲明，而不是一個函數(shù)調(diào)用。
python3 中print是一個函數(shù)

整除

Python 2.7.6
3 / 2 = 1
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0
Python 3.6.1
3 / 2 = 1.5
3 // 2 = 1
3 / 2.0 = 1.5
3 // 2.0 = 1.0

Unicode

Python 2 有 ASCII str() 類型，unicode() 是單獨(dú)的，不是 byte 類型。
現(xiàn)在， 在 Python 3，我們最終有了 Unicode (utf-8) 字符串，以及一個字節(jié)類：byte 和 bytearrays。

range xrange

在 Python 2 中 xrange() 創(chuàng)建迭代對象的用法是非常流行的。比如： for 循環(huán)或者是列表/集合/字典推導(dǎo)式。
這個表現(xiàn)十分像生成器（比如?！岸栊郧笾怠保５沁@個 xrange-iterable 是無窮的，意味著你可以無限遍歷。
由于它的惰性求值，如果你不得僅僅不遍歷它一次，xrange() 函數(shù) 比 range() 更快（比如 for 循環(huán)）。盡管如此，對比迭代一次，不建議你重復(fù)迭代多次，因?yàn)樯善髅看味紡念^開始。
在 Python 3 中，range() 是像 xrange() 那樣實(shí)現(xiàn)以至于一個專門的 xrange() 函數(shù)都不再存在（在 Python 3 中 xrange() 會拋出命名異常）。

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

python 2
print 'Python', python_version()
i = 1
print 'before: i =', i
print 'comprehension: ', [i for i in range(5)]
print 'after: i =', I

python3
print('Python', python_version())
i = 1
print('before: i =', i)
print('comprehension:', [i for i in range(5)])
print('after: i =', i)

通過input()解析用戶的輸入
詳情略
返回可迭代對象，而不是列表
略
詳情請移步

24.請描述unicode,utf-8,gbk等編碼之間的關(guān)系

#階段一：現(xiàn)代計(jì)算機(jī)起源于美國，最早誕生也是基于英文考慮的ASCII
ASCII:一個Bytes代表一個字符（英文字符/鍵盤上的所有其他字符），1Bytes=8bit，8bit可以表示0-2**8-1種變化，即可以表示256個字符

ASCII最初只用了后七位，127個數(shù)字，已經(jīng)完全能夠代表鍵盤上所有的字符了（英文字符/鍵盤的所有其他字符），后來為了將拉丁文也編碼進(jìn)了ASCII表，將最高位也占用了

#階段二:為了滿足中文和英文，中國人定制了GBK
GBK:2Bytes代表一個中文字符，1Bytes表示一個英文字符
為了滿足其他國家，各個國家紛紛定制了自己的編碼
日本把日文編到Shift_JIS里，韓國把韓文編到Euc-kr里

#階段三：各國有各國的標(biāo)準(zhǔn)，就會不可避免地出現(xiàn)沖突，結(jié)果就是，在多語言混合的文本中，顯示出來會有亂碼。如何解決這個問題呢？？？

#?。。。。。。。。。。?！非常重要！?。。。。。。。。。?！
說白了亂碼問題的本質(zhì)就是不統(tǒng)一，如果我們能統(tǒng)一全世界，規(guī)定全世界只能使用一種文字符號，然后統(tǒng)一使用一種編碼，那么亂碼問題將不復(fù)存在，
ps：就像當(dāng)年秦始皇統(tǒng)一中國一樣，書同文車同軌，所有的麻煩事全部解決
很明顯，上述的假設(shè)是不可能成立的。很多地方或老的系統(tǒng)、應(yīng)用軟件仍會采用各種各樣的編碼，這是歷史遺留問題。于是我們必須找出一種解決方案或者說編碼方案，需要同時滿足：
#1、能夠兼容萬國字符
#2、與全世界所有的字符編碼都有映射關(guān)系，這樣就可以轉(zhuǎn)換成任意國家的字符編碼

這就是unicode（定長），　統(tǒng)一用2Bytes代表一個字符，　雖然2**16-1=65535，但unicode卻可以存放100w+個字符，因?yàn)閡nicode存放了與其他編碼的映射關(guān)系，準(zhǔn)確地說unicode并不是一種嚴(yán)格意義上的字符編碼表，下載pdf來查看unicode的詳情：
鏈接：https://pan.baidu.com/s/1dEV3RYp

很明顯對于通篇都是英文的文本來說，unicode的式無疑是多了一倍的存儲空間（二進(jìn)制最終都是以電或者磁的方式存儲到存儲介質(zhì)中的）

于是產(chǎn)生了UTF-8（可變長，全稱Unicode Transformation Format），對英文字符只用1Bytes表示，對中文字符用3Bytes，對其他生僻字用更多的Bytes去存


#總結(jié)：內(nèi)存中統(tǒng)一采用unicode，浪費(fèi)空間來換取可以轉(zhuǎn)換成任意編碼（不亂碼），硬盤可以采用各種編碼，如utf-8，保證存放于硬盤或者基于網(wǎng)絡(luò)傳輸?shù)臄?shù)據(jù)量很小，提高傳輸效率與穩(wěn)定性。

?。?！重點(diǎn)！?。?

25.請描述with的用法？如果自己的類需要支持with語句，應(yīng)該如何書寫？

基本格式
with context_expression [as target(s)]:
    with-body

這里 context_expression 要返回一個上下文管理器對象，該對象并不賦值給 as 子句中的 target(s) ，
如果指定了 as 子句的話，會將上下文管理器的 __enter__() 方法的返回值賦值給 target(s)。
target(s) 可以是單個變量，或者由“()”括起來的元組（不能是僅僅由“,”分隔的變量列表，必須加“()”）。

自定義的上下文管理器要實(shí)現(xiàn)上下文管理協(xié)議所需要的 __enter__() 和 __exit__() 兩個方法
context_manager.__enter__() ：進(jìn)入上下文管理器的運(yùn)行時上下文，在語句體執(zhí)行前調(diào)用。with 語句將該方法的返回值賦值給 as 子句中的 target，如果指定了 as 子句的話
context_manager.__exit__(exc_type, exc_value, exc_traceback) ：退出與上下文管理器相關(guān)的運(yùn)行時上下文，返回一個布爾值表示是否對發(fā)生的異常進(jìn)行處理。

詳見
26.python中如果判斷一個對象是否可調(diào)用對象？那些對象可以是可調(diào)用對象？如何定義一個類，使其對象本身就是可調(diào)用對象？
可調(diào)用對象:任何可通過函數(shù)操作符()來調(diào)用的對象。Python有4種可調(diào)用對象：函數(shù)，方法，類，以及一些類的實(shí)例?！?br> 為了是一些類的實(shí)例是可調(diào)用對象必須在類中定義相應(yīng)的__call__方法
27.什么是裝飾器？寫一個裝飾器，可以打印輸出方法執(zhí)行時長的信息。
裝飾器:返回值是函數(shù)的高階函數(shù),主要作用是實(shí)現(xiàn)在不改變原函數(shù)的情況下對原函數(shù)進(jìn)行擴(kuò)展.減少代碼的重復(fù)編寫及使用

def deco(func):
    def inner(*args, **kwargs):
        now = time.time()
        ret = func(*args, **kwargs)
        print(time.time() - now)
        return ret
    return inner

@deco
def func():
    time.sleep(1)
    return 'hello'
print(func())

裝飾器詳解

28. 什么是進(jìn)程，線程，協(xié)程，說一說python對他們的支持？

進(jìn)程是一個具有獨(dú)立功能的程序關(guān)于某個數(shù)據(jù)集合的一次運(yùn)行活動。它可以申請和擁有系統(tǒng)資源，是一個動態(tài)的概念，是一個活動的實(shí)體。
它不只是程序的代碼，還包括當(dāng)前的活動，通過程序計(jì)數(shù)器的值和處理寄存器的內(nèi)容來表示。

線程，有時被稱為輕量級進(jìn)程(Lightweight Process，LWP），是程序執(zhí)行流的最小單元。一個標(biāo)準(zhǔn)的線程由線程ID，當(dāng)前指令指針(PC），寄存器集合和堆棧組 成。
另外，線程是進(jìn)程中的一個實(shí)體，是被系統(tǒng)獨(dú)立調(diào)度和分派的基本單位，線程自己不擁有系統(tǒng)資源，只擁有一點(diǎn)兒在運(yùn)行中必不可少的資源，但它可與同屬一個 進(jìn)程的其它線程共享進(jìn)程所擁有的全部資源

協(xié)程是一種用戶態(tài)的輕量級線程，即協(xié)程是由用戶程序自己控制調(diào)度的。
#1. python的線程屬于內(nèi)核級別的，即由操作系統(tǒng)控制調(diào)度（如單線程遇到io或執(zhí)行時間過長就會被迫交出cpu執(zhí)行權(quán)限，切換其他線程運(yùn)行）
#2. 單線程內(nèi)開啟協(xié)程，一旦遇到io，就會從應(yīng)用程序級別（而非操作系統(tǒng)）控制切換，以此來提升效率（?。?！非io操作的切換與效率無關(guān)）

詳情請見
29.def f(a,b=[])這種寫法中有什么陷阱?

變量b傳遞給函數(shù)的是指針,指針指向的是列表在內(nèi)存中的地址,在函數(shù)調(diào)用中對list的操作是對原地址進(jìn)行操作.
從而影響原有變量(默認(rèn)參數(shù)的內(nèi)容就變了，不再是函數(shù)定義時的[]了).

30.哪些情況下，y! = x - (x-y)會成立？
x,y是兩個不相等的非空集合
31.用python實(shí)現(xiàn)"九九乘法表"，用兩種不同的方式實(shí)現(xiàn)

for i in range(1, 10):
    print('')
    for j in range(1, i + 1):
        print(j, '*', i, '=', i * j, end='  ')

def f(i):
    if i >= 1:

        f(i - 1)
        print('')
        for j in range(1, i + 1):
            print('%s*%s=%s' % (j, i, i * j), end=' ')

f(9)

32.如何在Python中拷貝一個對象?并說明它們之間的區(qū)別

注意賦值和淺拷貝的區(qū)別
如l1 = ['a','b','c'] # 這段代碼是是對l1 的初始化操作,開辟一個內(nèi)存空間存儲列表,l1 這個變量指向這個列表
l2 = l1 # 這屬于賦值操作
# 如果更改l1,l2也會一起改變,因?yàn)閮蓚€變量指向的是同一個位置
import copy
淺拷貝：不管多么復(fù)雜的數(shù)據(jù)結(jié)構(gòu)，淺拷貝都只會copy一層
copy.copy(...),在多層嵌套時可能會一個數(shù)據(jù)可改變可能會影響其他的數(shù)據(jù).
深拷貝:深拷貝會完全復(fù)制原變量相關(guān)的所有數(shù)據(jù)，在內(nèi)存中生成一套完全一樣的內(nèi)容，在這個過程中我們對這兩個變量中的一個進(jìn)行任意修改都不會影響其他變量.
深拷貝就是在內(nèi)存中重新開辟一塊空間，不管數(shù)據(jù)結(jié)構(gòu)多么復(fù)雜，只要遇到可能發(fā)生改變的數(shù)據(jù)類型，就重新開辟一塊內(nèi)存空間把內(nèi)容復(fù)制下來，直到最后一層，不再有復(fù)雜的數(shù)據(jù)類型，就保持其原引用。這樣，不管數(shù)據(jù)結(jié)構(gòu)多么的復(fù)雜，數(shù)據(jù)之間的修改都不會相互影響
copy.deepcopy(...)

詳情請見
33.談?wù)勀銓ython裝飾器的理解
python裝飾器就是接收某一個函數(shù)作為參數(shù)并且返回值為函數(shù)的高階函數(shù),
主要作用是實(shí)現(xiàn)在不改變原函數(shù)的情況下對原函數(shù)進(jìn)行擴(kuò)展.減少代碼的重復(fù)編寫及使用.
34.Python里面match()和search()的區(qū)別？(**)
參見其他題目
35.獲取list的元素個數(shù)，和向末尾追加元素所用的方法分別是？

.count(*)# 計(jì)算某個元素的個數(shù)
.append() # 添加元素的方法
.sort()# 對列表進(jìn)行排序

36.在數(shù)組中找到具有最大和的連續(xù)子數(shù)組(至少包含一個數(shù)字)
例如給定數(shù)組[-2,1,-3,4,-1,1,1,-5,4]
連續(xù)子陣列[4,-1,2,1]具有最大和6.

def maxSubArray(nums):
    # write your code here
    n = len(nums)
    maxSum = sum(nums)
    curSum = 0
    for i in range(n):
        # 從i開始求和，如果當(dāng)前和大于maxSum,則賦值給maxSum
        curSum += nums[i]
        if curSum > maxSum:
            maxSum = curSum
        # 前面的和如果已經(jīng)小于0了，那么加上下一個元素值，肯定是小于下一個元素值
        # 所以如果前面加起來的值小于0了，則舍棄前面的和，從下一位開始繼續(xù)求和
        if curSum < 0:
            curSum = 0
    return maxSum

l = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(maxSubArray(l))

37 . new 和 init

class B(object):
    def fn(self):
        print 'B fn'
    def __init__(self):
        print "B INIT"


class A(object):
    def fn(self):
        print 'A fn'

    def __new__(cls,a):
            print "NEW", a
            if a>10:
                return super(A, cls).__new__(cls)
            return B()

    def __init__(self,a):
        print "INIT", a

a1 = A(5)
a1.fn()
a2=A(20)
a2.fn()

NEW 5
B INIT
B fn
NEW 20
INIT 20
A fn

38.getattr方法的應(yīng)用

class A(object):
    def __init__(self,a,b):
        self.a1 = a
        self.b1 = b
        print 'init'
    def mydefault(self,*args):
        print 'default:' + str(args[0])
    def __getattr__(self,name):
        print "other fn:",name
        return self.mydefault

a1 = A(10,20)
a1.fn1(33)
a1.fn2('hello')
a1.fn3(10)

39.包管理
一個包里有三個模塊，mod1.py, mod2.py, mod3.py，但使用from demopack import *導(dǎo)入模塊時，如何保證只有mod1、mod3被導(dǎo)入了。

答案:增加init.py文件，并在文件中增加：

__all__ = ['mod1','mod3']

40.閉包
寫一個函數(shù)，接收整數(shù)參數(shù)n，返回一個函數(shù)，函數(shù)的功能是把函數(shù)的參數(shù)和n相乘并把結(jié)果返回。

def mulby(num):
    def gn(val):
        return num * val

    return gn


zw = mulby(7)
print(zw(9));