1.列表(list)和元組(tuple)的區別

列表是可以修改的
元組不能修改

定義:
list: 連結串列, 有序的專案, 通過索引進行查詢, 使用方括號"[]";
tuple:元組, 元組將多樣的物件集合到一起, 不能修改, 通過索引進行查詢, 使用括號"()";
dict:字典, 字典是一組鍵(key)和值(value)的組合, 通過鍵(key)進行查詢, 沒有順序, 使用大括號"{}";
set:集合,無序, 元素只出現一次, 自動去重, 使用"set([])"; 應用場景:
1. list, 簡單的資料集合, 可以使用索引;
2. tuple, 把一些資料當做一個整體去使用, 不能修改;
 

3. dict, 使用鍵值和值進行關聯的資料;
4. set, 資料只出現一次, 只關心資料是否出現, 不關心其位置;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

2. 集合(set)是怎樣的一種資料型別，何時使用？

set集合，是一個無序且不重複的元素集合。
集合物件是一組無序排列的可雜湊的值，集合成員可以做字典中的鍵。集合支援用in和not in
操作符檢查成員，由len()內建函式得到集合的基數(大小)， 用 for 迴圈迭代集合的成員。但是
因為集合本身是無序的，不可以為集合建立索引或執行切片(slice)操作，也沒有鍵(keys)可用
來獲取集合中元素的值。

• 1
• 2
• 3
• 4
• 5
• 6
• 7

3.請在下面的空白處填寫執行結果

>>>seq = [1, 2, 3, 4]
>>>seq[:2]
_____________________________
>>>seq[-2:]
_____________________________
>>>seq[10:]
_____________________________
>>>seq[::-1]
_____________________________
>>>seq[:]
_____________________________
>>> id(seq[:]
 
) == id(seq)
_____________________________

>>> seq = [1, 2, 3, 4]
>>> seq[-2]
3
>>> seq[10:]
[]
>>> seq[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> seq[::-1]
[4, 3, 2, 1]
>>> seq[:]
[1, 2, 3, 4]
>>> id(seq[:]) == id(seq)
False
>>> 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

4.優化以下程式

result = []
for x in range(10):
result.append(x ** 2)
print(result)
優化後
>>> result = [x**2 for x in range(10)]
>>> print result
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

5.函式、類方法定義中如何實現可選引數、可選關鍵詞引數

deffuncArgsTest(a,b,c=100,*argc,**kwarg):
    sum = a + b + c
    for d in argc:
        sum += d
    for v in kwarg.itervalues():
        sum += v
    return sum

print funcArgsTest(100,200,300,500,600,aa=700,bb=900,cc=1000)

==>4300

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

6.請解釋classmethod和staticmethod的區別

classClassTest(object):
    def__init__(self,a):
        self.a = a
    defprintk(self):
        print "a is ",self.a

    @classmethod
    defclass_method(*args):
        print  "args is ",args


    @classmethod
    defclass_method2(cls):
        print "cls is ",cls


    @staticmethod
    defstatic_method(*args):
        print "args is ",args

ct = ClassTest(100)
ct.printk()
ct.class_method()
ct.static_method()
ct.class_method2()

==>
a is  100
args is  (<class '__main__.ClassTest'>,)
args is  ()
cls is  <class '__main__.ClassTest'>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

7. 請給出下列程式的執行結果

>>>x = 0.5
>>>while x != 1.0
>>>print(x)
>>> x += 0.1
此題考查浮點數比較相等的情況，x != 1.0 這樣程式並不會結束
因為浮點數相等比較不能通過==,應該是一個範圍,可以使用 x <= 1.0

• 1
• 2
• 3
• 4
• 5
• 6
• 7

8.請寫一段程式，包含迭代器和生成器的使用

>>> for xa in (x for x in range(10)):
...    print xa
... 
0
1
2
3
4
5
6
7
8
9

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

9.請根據age分別對student_tuples及student_objects進行排序

>>>student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
說明：每一行的三個元素分別代表name, grade, age.
>>> classStudent:
def__init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def__repr__(self):
return repr((self.name, self.grade, self.age))
>>>student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),


sorted(student_tuples,key = lambda x : x[2])
sorted(student_objects,key = lambda s : s.age)


classStudent:

   def__init__(self, name, grade, age):

      self.name = name

      self.grade = grade

      self.age = age

   def__repr__(self):
      return repr((self.name, self.grade, self.age))

student_objects = [

Student('john', 'A', 15),

Student('jane', 'B', 12),

Student('dave', 'B', 10),
]
print sorted(student_objects,key = lambda s:s.age)


[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50

10.如何使用匿名函式

>>> map(lambda x : x**2,[1,2,3])
[1, 4, 9]
>>> filter(lambda x: x >1 ,[1,2,3])
[2, 3]
>>> map(lambda x : x**2,[1,2,3])
[1, 4, 9]
>>> reduce(lambda x,y: x + y,[1,2,3])
6
>>> filter(lambda x: x >1 ,[1,2,3])
[2, 3]
>>> 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

11.何時使用標準庫 collections 中的deque？

deque其實是 double-ended queue 的縮寫，翻譯過來就是雙端佇列，它最大的好處就是實現了從佇列 頭部快速增加和取出物件: 
.popleft(), 
.appendleft()
但是值得注意的是，list物件的這兩種用法的時間複雜度是 O(n) ，也就是說隨著元素數量的增加耗時呈 線性上升。而使用deque物件則是 O(1) 的複雜度，所以當你的程式碼有這樣的需求的時候， 一定要記得使用deque。

deque還可以限制佇列長度，如果長於佇列則會刪除

如果是是append則會刪除最左端的元素
如果是apppendleft則會刪除最右端的元素

>>> dq = deque([],3)
>>> dq.append(1)
>>> dq.append(2)
>>> dq.append(3)
>>> print dq
deque([1, 2, 3], maxlen=3)
>>> dq.append(4)
>>> print dq
deque([2, 3, 4], maxlen=3)

>>> dq = deque([],3)
>>> print dq
deque([], maxlen=3)
>>> dq.append(1)
>>> dq.append(2)
>>> dq.append(3)
>>> print dq
deque([1, 2, 3], maxlen=3)
>>> dq.appendleft(4)
>>> print dq
deque([4, 1, 2], maxlen=3)
>>> 


collections中有幾個非常好用的資料型別
Python擁有一些內建的資料型別，比如str, int, list, tuple, dict等， collections模組在這些內建資料型別的基礎上，提供了幾個額外的資料型別：

    namedtuple(): 生成可以使用名字來訪問元素內容的tuple子類
    deque: 雙端佇列，可以快速的從另外一側追加和推出物件
    Counter: 計數器，主要用來計數
    OrderedDict: 有序字典
    defaultdict: 帶有預設值的字典

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43

12.標準庫 copy 中的 copy 和deepcopy的區別

copy.copy()是淺拷貝
copy.deepcopy()是深拷貝
>>> import copy
>>> lista = [1,2,3,['a','b']]
>>> listb = copy.copy(lista)
>>> listc = copy.deepcopy(lista)
>>> lista
[1, 2, 3, ['a', 'b']]
>>> listb
[1, 2, 3, ['a', 'b']]
>>> listc
[1, 2, 3, ['a', 'b']]
>>> lista.append(5)
>>> lista
[1, 2, 3, ['a', 'b'], 5]
>>> listb
[1, 2, 3, ['a', 'b']]
>>> listc
[1, 2, 3, ['a', 'b']]
>>> id(lista)
3085189868L
>>> id(listb)
3084763820L
>>> id(listc)
3085198380L

>>> lista[3].append('c') 
>>> lista
[1, 2, 3, ['a', 'b', 'c'], 5]
>>> listb
[1, 2, 3, ['a', 'b', 'c']]
>>> listc
[1, 2, 3, ['a', 'b']]
>>> 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35

13.標準庫 re 正則表示式 match 和 search 區別

re.match是從字串首字母處匹配
re.search是遍歷整個字串匹配


>>> str1 = "<abc>aaa</abc>"
>>> re.match("<",str1)
<_sre.SRE_Match object at 0xb7dd7e90>
>>> m = re.match("<",str1)
>>> m.group()
'<'
>>> str1 = "xyz<abc>aaa</abc>"
>>> m = re.match("<",str1)
>>> m.group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> re.search("<",str1)
<_sre.SRE_Match object at 0xb7dd2988>
>>> ms = re.search("<",str1)
>>> ms.group()
'<'
>>> 


>>> import re
>>> help(re.match)
Help on function match in module re:

match(pattern, string, flags=0)
    Try to apply the pattern at the start of the string, returning
    a match object, or None if no match was found.

>>> help(re.search)
Help on function search in module re:

search(pattern, string, flags=0)
    Scan through string looking for a match to the pattern, returning
    a match object, or None if no match was found.

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

14.使用正則表示式在’’’待處理

OPTION’’’字串中, 獲取OPTION的value屬性值.注意: OPTION中可能有其他的標籤屬性,如: 或者

>>> str1 = '<OPTION value="TBD">TBD</OPTION>OPTION'

>>> m = re.match(r"(<OPTION\s+[a-z]*[=]*\w*\s*)(value=)(\"\w+\")",str1)
>>> m.group(3)
'"TBD"'


>>> str1 = '<OPTION  aa=2 value="TBD">TBD</OPTION>OPTION'
>>> m = re.match(r"(<OPTION\s+[a-z]*[=]*\w*\s*)(value=)(\"\w+\")",str1)
>>> m.group(3)
'"TBD"'



>>> str1 = '<OPTION  aa=2 value="TBD" bb=2>TBD</OPTION>OPTION'
>
>>> m = re.match(r"(<OPTION\s+[a-z]*[=]*\w*\s*)(value=)(\"\w+\")",str1)
>>> m.group(3)
'"TBD"'

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

15.如何使用標準庫pdb除錯 Python 程式

在python中使用pdb模組可以進行除錯
import pdb
pdb.set_trace()

也可以使用python -m pdb myscript.py這樣的方式

• 1
• 2
• 3
• 4
• 5

16.什麼是裝飾器，如何使用裝飾器

deflog(level):
    defdec(func):
        defwrapper(*kargc,**kwargs):
            print "before func was called"
            func(*kargc,**kwargs)
            print "after func was called"
        return wrapper
    return dec

@log(2)
deffuncLog():
    print "funcLog was called"

funcLog()

==>
before func was called
funcLog was called
after func was called

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

17.請解釋with關鍵字的用法

with關鍵字的前提是類需要實現__enter__和__exit__
>>> with open("test.sh") as f:
...    f.read()

• 1
• 2
• 3
• 4

18.引數傳遞使用的是傳遞引用還是傳遞值？為什麼？

對於變數（與物件相對的概念），其實，python函式引數傳遞可以理解為就是變數傳值操作

不可變物件引數呼叫

defChangeInt( a ):
    a = 10
nfoo = 2 
ChangeInt(nfoo)
print nfoo #結果是2


可變物件引數呼叫

defChangeList( a ):
    a[0] = 10
lstFoo = [2]
ChangeList(lstFoo )
print nfoo #結果是[10]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

19.在類的方法定義中’self’是怎樣的一個引數

self在Python裡不是關鍵字。self代表當前物件的地址。self能避免非限定呼叫造成的全域性變數。
self在定義時需要定義，但是在呼叫時會自動傳入。
self的名字並不是規定死的，但是最好還是按照約定是用self
self總是指呼叫時的類的例項

• 1
• 2
• 3
• 4
• 5
• 6

20.說明CPython的記憶體管理機制

變數的儲存有三個區域，事先分配的靜態記憶體、事先分配的可重複利用記憶體以及需要通過malloc和free來控制的自由記憶體。
python的記憶體在底層也是由malloc和free的方式來分配和釋放，只是它代替程式設計師決定什麼時候分配什麼時候釋放，同時也提供介面讓使用者手動釋放，因此它有自己的一套記憶體管理體系，主要通過兩種機制來實現，一個是引用計數，一個是垃圾回收。前者負責確定當前變數是否需要釋放，後者解決前者解決不了的迴圈引用問題以及提供手動釋放的介面del。

• 1
• 2
• 3
• 4