Python核心編程--學習筆記--6--序列（下）列表、元組
11 列表
相似於C語言的數組，可是列表能夠包含不一樣類型的任意對象。列表是可變類型。python
建立列表——手動賦值、工廠函數：git
>>> aList = [12, 'abc'] >>> print aList [12, 'abc'] >>> list('foo') #參數爲可迭代對象
['f', 'o', 'o']
訪問列表元素——下標[]或者切片[:]。正則表達式
更新列表——直接對索引/索引範圍賦值：算法
>>> aList[0] = 'def' #對一個索引賦值
>>> aList ['def', 'abc'] >>> aList[0], aList[1] = 'mn', 'xyz' #對一個索引範圍賦值 >>> aList ['mn', 'xyz'] >>> aList[:] = 'ab', 'cd' #列表從新賦值 >>> aList ['ab', 'cd'] >>> aList[:] = 'ab', 'cd', 'ef' #超出原列表長度 ['ab', 'cd', 'ef'] >>> aList.append('gh') #append()方法，在後面添加 >>> aList ['ab', 'cd', 'ef', 'gh']
刪除列表元素/列表自己：數組
>>> del aList[2] #根據下標刪除 >>> aList ['ab', 'cd', 'gh'] >>> aList.remove('cd') #若是知道元素內容，則直接刪除該元素 >>> aList ['ab', 'gh'] >>> del aList #刪除列表自己，並不須要顯示調用，在程序結束時自會收回內存的 >>> aList Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'aList' is not defined
12 操做符
12.1 標準類型操做符
比較運算：兩個列表的元素分別比較，直到有一方的元素勝出。數據結構
>>> alist = ['abc', 123] >>> blist = ['xyz', 789] >>> clist = ['abc', 123] >>> alist < blist True >>> alist == clist True
12.2 序列類型操做符
切片操做符[]、成員操做符[not] in、鏈接操做符+、重複操做符* 都適用於列表。有幾個要注意的點：app
>>> alist = [1, 2] >>> alist [1, 2] >>> alist[1] = [1, 2] #對某一索引賦值，則新值代替該元素 >>> alist [1, [1, 2]] >>> alist[:1] = [1, 2] #對某一範圍賦值，則新值直接做爲元素覆蓋原來範圍 >>> alist [1, 2, [1, 2]] >>> alist + [3, 4] [1, 2, [1, 2], 3, 4] >>> alist #鏈接操做符並不在原對象上進行修改，且只能和列表對象鏈接 [1, 2, [1, 2]] >>> alist.extend('abc') #extend()函數將參數的每一個元素做爲原對象的元素，參數爲可迭代對象 >>> alist [1, 2, [1, 2], 'a', 'b', 'c'] >>> alist.append('abc') #append()函數將參數總體做爲最後一個元素 >>> alist [1, 2, [1, 2], 'a', 'b', 'c', 'abc']
12.3 列表解析
列表沒有本身專門的操做符，可是有本身專屬的列表解析：dom
>>> [ i * 2 for i in [8, -2, 5] ] [16, -4, 10] >>> [ i for i in range(8) if i % 2 == 0 ] [0, 2, 4, 6]
13 內建函數
13.1 標準類型函數
cmp()也能夠用於列表比較。比較時逐元素比較，知道比出大小：數字按大小比較，字符串按字符ASCII碼值比較，數字永遠小於字符串。ide
13.2 序列類型函數
len()——返回元素個數函數
max()、min()——返回最大/最小元素值。包含複雜對象時，返回不必定準確。
sorted()、reversed()——返回排序的列表/逆序的迭代對象。字符串排序的時候按照字典序，即ASCII碼值順序。
enumerate()、zip()——同序列中的功能。
sum()——求和。只對整數列表，並且還有個默認參數。
list()、tuple()——將一個可迭代對象轉換成一個列表/元組對象。（原對象不變，生成一個新對象）
14 列表類型的內建函數（方法）
Python中沒有用於列表的專用內建函數，可是列表類型有本身的類方法。
列表是可變類型，這些方法直接在原列表上進行修改，因此沒有返回值（相比字符串就必須返回新對象）：
1 list.append(obj) #向列表中添加一個對象obj
2 list.count(obj) #返回一個對象obj在列表中出現的次數
3 list.extend(seq) #把序列seq的元素做爲列表元素添加到列表中
4 list.index(obj, i=0, j=len(list)) #返回第一個值爲obj的下標，不存在則引起ValueError異常
5 list.insert(index, obj) #在索引值爲index的位置插入對象obj
6 list.pop(index=-1) #刪除並返回指定位置的對象，默認是最後一個對象
7 list.remove(obj) #從列表中刪除對象obj
8 list.reverse() #原地翻轉列表
#重排序列表，若是func和key參數指定，則按照指定的方式比較各個元素,若是reverse標誌被置爲True，則列表以反序排列
9 list.sort(func=None,key=None, reverse=False)
15 列表的特殊特性
列表有容器和可變的特性，能夠用來實現其餘數據結構——棧、隊列。
棧——後進先出：
#!/usr/bin/env python
'my stack' stack = [] #空列表，用於保存棧元素
def pushit(): #入棧，加到列表尾部
stack.append(raw_input('Enter new string: ').strip()) def popit(): #出棧
if len(stack) == 0: print 'Cannot pop from an empty stack!'
else: print 'Removed [', `stack.pop()`, ']' #list.pop()默認彈出最後一個元素，用反引號將其轉爲字符串
def viewstack(): #打印棧(列表)內容
print stack CMDs = {'u': pushit, 'o': popit, 'v': viewstack} #字典，值是函數名
def showmenu():
pr = """ p[U]sh p[O]p [V]iew [Q]uit Enter choice: """
while True: #主循環，根據輸入決定流程
while True: #輸入循環，判斷輸入是否正確
try: choice = raw_input(pr).strip()[0].lower() #分別輸入^D（EOF）、^C（中斷退出）、輸入爲空或只有空字符 時致使的錯誤
except (EOFError, KeyboardInterrupt, IndexError): choice = 'q'
print '\nYou picked: [%s]' % choice if choice not in 'uovq': print 'Invalid option, try again'
else: break
if choice == 'q': break CMDs[choice]() #根據輸入，讀字典的值，並調用函數
if __name__ == '__main__': #若是在命令行執行，則if成功；若是做爲模塊導入，則判斷失敗
showmenu()
列表——先進先出：
#!/usr/bin/env python
'my queue' queue = [] def enQ(): queue.append(raw_input('Enter new string: ').strip()) def deQ(): if len(queue) == 0: print 'Cannot pop from an empty queue!'
else: print 'Removed [', `queue.pop(0)`, ']' #差異只在於，每次彈出第一個元素
def viewQ(): print queue CMDs = {'e': enQ, 'd': deQ, 'v': viewQ} def showmenu(): pr = """ [E]nqueue [D]equeue [V]iew [Q]uit Enter choice: """
while True: while True: try: choice = raw_input(pr).strip()[0].lower() except (EOFError, KeyboardInterrupt, IndexError): choice = 'q'
print '\nYou picked: [%s]' % choice if choice not in 'devq': print 'Invalid option, try again'
else: break
if choice == 'q': break CMDs[choice]() if __name__ == '__main__': showmenu()
16 元組
元組和列表有不少類似性，不一樣點在於：元組用圓括號()包圍；元組是不可變類型。
建立元組——直接賦值、工廠函數：
>>> atuple = (12, 'abc', [34, 'def']) >>> atuple (12, 'abc', [34, 'def']) >>> btuple = (123) #一個例外：只有一個元素時，要加逗號，不然括號就變爲普通的括號 >>> btuple 123
>>> type(btuple) <type 'int'>
>>> btuple = (123, ) #加逗號表示一個元組 >>> btuple (123,) >>> type(btuple) <type 'tuple'>
>>> tuple('foo') #參數爲可迭代對象 ('f', 'o', 'o')
訪問元素——下標[]或者切片[:]。
更新元組：同字符串同樣，元組的內容是不能夠改變的，當變量被賦與其它元組時，實際上是生成了一個新的元組對象。
刪除元組：刪除元組元素是不可能的，能夠調用del來刪除整個元組，原理同刪除列表同樣。
17 元組操做符和內建函數
標準類型操做符：比較運算符、邏輯運算符都適用於元組，原理同列表。
序列類型操做符：切片操做符[]、成員操做符[not] in、鏈接操做符+、重複操做符* 都適用於元組。
內建函數：cmp()函數、序列類型函數仍然適用於元組。（sorted()返回的是排序好的列表）
Python沒有專門用於元組的操做符和內建函數，元組類型只有兩個方法——統計和查找：
1 tuple.count(obj) #返回一個對象obj在元組中出現的次數
2 tuple.index(obj, i=0, j=len(tuple)) #返回第一個值爲obj的下標，若是不存在則引起ValueError異常
18 元組的特殊性
18.1 不可變性的影響
切片操做不能做爲左值被賦值；被傳給其餘函數時，能夠確保數據不被修改。
18.2 元組的一個「可變性」
若是元組裏面有可變類型的元素，那個這個元素的內容仍是能夠改變的：
>>> t1 = ([1,2], 3) >>> t1 ([1, 2], 3) >>> t1[0][1] = [4, 'abc'] >>> t1 ([1, [4, 'abc']], 3)
18.3 默認集合類型
幾個沒有明確符號定義的，只是用逗號隔開的對象，默認是一個元組類型：
>>> 1, 3 < 2, 4 #逗號優先級小於比較符號，不加括號帶來的反作用
(1, False, 4) >>> (1, 3) < (2, 4) True >>> def foo(): ... return rt1, rt2, rt3 #實際返回的是一個元組
18.4 單元素元組
以前已經介紹過，單元素的元組建立時，應該在這個元素後面加一個逗號；以此防止括號被當成分組操做符。
18.5 字典的關鍵字
字典的原理就是哈希表，其鍵應該是惟一的，因此它的鍵必須是不可變類型。
列表VS元組
不可變類型：當須要把一組數據傳遞給一個陌生函數時，應該使用元組，防止數據被修改。
可變類型：在管理動態數據集時，須要不按期的增刪改元素。
轉換：list()和tuple()能夠將對象在列表和元組之間轉換。
19 相關模塊
與序列類型相關的模塊：
1 數組 #一種受限制的可變序列類型，要求全部的元素必須都是相同的類型
2 copy #提供淺拷貝和深拷貝的能力
3 operator #包含函數調用形式的序列操做符，好比operator.concat(m,n)就至關於鏈接操做(m+n)
4 re #Perl風格的正則表達式查找(和匹配);見第 15 章
5 StringIO/cStringIO #把長字符串做爲文件來操做，好比read()、seek()函數等，C版的更快一些，可是不能被繼承
6 textwrap #用做包裹/填充文本的函數，也有一個類
7 types #包含Python支持的全部類型
8 collections #高性能容器數據類型
20 拷貝Python對象
拷貝只發生在容器類型中（即列表、元組等），淺拷貝的概念能夠經過如下例子來理解：
>>> aList = ['a', ['aa', 100]] >>> bList = aList[:] #經過切片操做符來複制列表（按照概念，就是切片操做返回一個新列表對象，而後將其引用賦值給新變量） >>> cList = list(aList) #經過工廠函數來複制列表 >>> [id(x) for x in aList, bList, cList] #打印三個列表id值，都不同 [158368652, 158358316, 158212652] >>> for xList in aList, bList, cList: #打印三個列表的元素值，都同樣 ... [id(x) for x in xList] ... [3073138104L, 157929228] [3073138104L, 157929228] [3073138104L, 157929228]
經過以上例子可知，淺拷貝的時候，只是建立了一個和被複制對象同樣類型的新對象（類型、元素數目、值都同樣），而其中的元素仍是指向了被複制對象的元素。若是更新某一個對象中的可變類型，會影響到其餘的對象。
深拷貝的意思則顯而易見：
>>> import copy >>> dList = copy.deepcopy(aList) #模塊裏的深拷貝函數 >>> eList = copy.copy(aList) #模塊裏的淺拷貝函數 >>> [id(x) for x in aList, dList, eList] #仍然生成兩個新的列表對象 [158368652, 158368140, 158215884] >>> for xList in aList, dList, eList: ... [id(x) for x in xList] ... [3073138104L, 157929228] [3073138104L, 158358348] #第一個元素都是指向同一個字符串對象，而深拷貝的時候，第二個列表元素則爲新建立的列表對象 [3073138104L, 157929228]
總結：
淺拷貝有三種：①切片[:]，②工廠函數list()、dict()等、③copy()函數。元組淺拷貝時甚至不生成新對象，直接把被複制對象的引用賦值給新變量。
深拷貝的時候，建立一個新對象，其中的不可變類型元素仍指向被複制對象的相應元素，而可變類型元素則爲新建立對象。若是元組中不包含不可變類型的元素，則仍然進行淺拷貝。
21 序列類型小結
序列：順序存儲——字符串、列表、元組。
序列操做符：鏈接+、重複*、切片[:]、成員[not] in。
方法：seq.method()。
練習題
6-3 排序 (a)輸入一串數字，從大到小排列之。 (b)跟a同樣，不過要用字典序從大到小排列之。
1 #!/usr/bin/env Python 2 3 dict_sorted_list = [] 4 numbers = raw_input('Enter the numbers separated by space: ').split() 5 6 for x in sorted(numbers, reverse = True): 7 dict_sorted_list.append(int(x)) 8 9 for i,x in enumerate(numbers): 10 numbers[i] = int(x) 11 12 sorted_list = sorted(numbers, reverse = True) 13 14 print 'orignal input:', numbers 15 print ' sorted:', sorted_list 16 print ' dict sorted:', dict_sorted_list
6–5 字符串
(a)輸入一個字符串，逐字符顯示。且每次都向前向後多顯示一個字符。
(b)經過掃描來判斷兩個字符串是否匹配(不能使用比較操做符或者cmp()內建函數)。附加題：在你的方案里加入大小寫區分。
(c)判斷一個字符串是否重現(後面跟前面的一致)。附加題：在處理除了嚴格的迴文以外，加入對例如控制符號和空格的支持。
(d)接受一個字符，在其後面加一個反向的拷貝，構成一個迴文字符串。
1 #!/usr/bin/env Python 2 3 mystr = raw_input('Enter your string: ') 4 mylen = len(mystr) 5 6 if mylen == 0: 7 print 'input none' 8 elif mylen == 1: 9 print mystr 10 else: 11 for i in range(mylen): 12 if i == 0: 13 print mystr[0], mystr[1] 14 elif i == mylen - 1: 15 print mystr[i - 1], mystr[i] 16 else: 17 print mystr[i - 1], mystr[i], mystr[i + 1]
1 #!/usr/bin/env Python 2 3 mystr1 = raw_input('1st string: ').strip() 4 mystr2 = raw_input('2nd string: ').strip() 5 mylen1 = len(mystr1) 6 flag = True 7 8 if mylen1 - len(mystr2): 9 flag = False 10 else: 11 for i in range(mylen1): 12 if ord(mystr1[i]) - ord(mystr2[i]): 13 flag = False 14 break 15 16 if flag: 17 print 'equal' 18 else: 19 print 'not equal'
1 #!/usr/bin/env Python 2 3 mystr = raw_input('Enter your string: ').strip() 4 mylen = len(mystr) 5 flag = True 6 7 for i in range(mylen/2): 8 if mystr[i] != mystr[mylen - 1 - i]: 9 flag = False 10 break 11 12 if flag: 13 print 'is palindrome' 14 else: 15 print 'not palindrome'
1 #!/usr/bin/env Python 2 3 mystr = raw_input('Enter your string: ').strip() 4 palin = mystr + mystr[::-1] 5 print palin
6–6 字符串。建立一個string.strip()的替代函數：接受一個字符串，去掉它前面和後面的空格。（若是使用string.*strip()函數那本練習就沒有意義了）
1 #!/usr/bin/env Python 2 3 mystr = raw_input('Enter your string: ') 4 5 for beg,val in enumerate(mystr): 6 if val != ' ' and val != '\t': 7 break 8 9 for end,val in enumerate(reversed(mystr)): 10 if val != ' ' and val != '\t': 11 break 12 13 end = len(mystr) - 1 - end 14 15 mystrip = mystr[beg:end+1] 16 print mystrip
6–7 調試。以下例代碼：
(a)研究這段代碼並描述這段代碼想作什麼。在全部的(#)處都要填寫你的註釋。
(b)這個程序有一個很大的問題，好比輸入六、十二、20、30等它會死掉，實際上它不能處理任何的偶數，找出緣由。
(c)修正(b)中提出的問題。
1 #!/usr/bin/env Python 2 3 #輸入一個整數 4 num_str = raw_input('Enter a number: ') 5 6 #將輸入的轉換爲整數對象 7 num_num = int(num_str) 8 9 #生成一個列表，範圍爲[1, num_num]，並打印列表 10 fac_list = range(1, num_num + 1) 11 print "BEFORE:", fac_list 12 13 #列表下標 14 i = 0 15 16 #遍歷列表 17 while i < len(fac_list): 18 #若是輸入的數能被當前元素整出，則刪除該元素 19 if num_num % fac_list[i] == 0: 20 del fac_list[i] 21 22 #下標前進1 23 i = i + 1 24 25 print "AFTER:", fac_list
(b)第23行，當刪除元素後，下標已經指向了新元素，再前進1就跳過了一個元素。
(c)對19行的if加一個else，把第23行掛在else之下便可。
6–8 列表。給出一個整數值，返回表明該值的英文，好比輸入89返回"eight-nine"。附加題：可以返回符合英文語法規則的形式，好比輸入「89」返回「eighty-nine」。本練習中的值限定在[0, 1000]。
1 #!/usr/bin/env python 2 3 single_digits = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 4 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'] 5 tens_digits = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'] 6 7 while True: 8 num = int(raw_input('Enter a number (0, 1000): ')) 9 if 0 < num < 1000: 10 break 11 else: 12 print 'Input error!' 13 14 #no syntax 15 result = '' 16 tmpnum = num 17 while tmpnum: 18 result = single_digits[tmpnum % 10] + '-' + result 19 tmpnum /= 10 20 21 print result[:-1] 22 23 #syntax 24 result = '' 25 tmpnum = num 26 if tmpnum >= 100: 27 result = '-' + single_digits[tmpnum / 100] + ' hundred' 28 tmpnum %= 100 29 30 if 0 < tmpnum <= 19: 31 result += '-' + single_digits[tmpnum] 32 elif 20 <= tmpnum <= 99: 33 result += '-' + tens_digits[tmpnum / 10 - 2] 34 if tmpnum % 10: 35 result += '-' + single_digits[tmpnum % 10] 36 37 print result[1:]
6–10 字符串。寫一個函數，返回一個跟輸入字符串類似的字符串，要求字符串的大小寫反轉。好比，輸入"Mr.Ed"，應該返回"mR.eD"做爲輸出。
1 #!/usr/bin/env python 2 3 import string 4 5 mystr = raw_input('Enter your string: ') 6 chrlist = list(mystr) 7 8 for idx in range(len(mystr)): 9 if chrlist[idx] in string.lowercase: 10 chrlist[idx] = chrlist[idx].upper() 11 elif chrlist[idx] in string.uppercase: 12 chrlist[idx] = chrlist[idx].lower() 13 14 print ''.join(chrlist)
6–11 轉換。(a)建立一個從整數到IP地址的轉換程序，以下格式：WWW.XXX.YYY.ZZZ (b)更新你的程序，使之能夠逆轉換。
1 #!/usr/bin/env python 2 3 ipnum = input('Enter a number: ') 4 ipadd = raw_input('Enter an ip address: ').strip() 5 6 print 'int -> ip address' 7 ips = [] 8 for i in range(24, -1, -8): 9 ips.append(str( (ipnum >> i) & 0xFF )) 10 print '%d -> %s' % (ipnum, '.'.join(ips)) 11 12 print 'ip address -> int' 13 ipint = 0 14 for i,ipstr in enumerate(ipadd.split('.')): 15 ipint += int(ipstr) << ((3 - i) * 8) 16 print '%s -> %d' % (ipadd, ipint)
6–12 字符串。
(a)建立一個名字爲findchr()的函數，函數聲明以下:
def findchr(string, char)
findchr()要在字符串string中查找字符char，找到就返回該值的索引，不然返回-1。不能用string.*find()或者string.*index()函數和方法。
(b)建立另外一個叫rfindchr()的函數，查找字符char最後一次出現的位置。它跟findchr()工做相似，不過它是從字符串的最後開始向前查找的。
(c)建立第三個函數，名字叫subchr()，聲明以下：
def subchr(string, origchar, newchar)
subchr()跟 findchr()相似，不一樣的是，若是找到匹配的字符就用新的字符替換原先字符。返回修改後的字符串。
1 def findchr(string, char): 2 for i,chr in enumerate(string): 3 if chr == char: 4 return i 5 return -1 6 7 def rfindchr(string, char): 8 for i,chr in enumerate(reversed(string)): 9 if chr == char: 10 return len(string) - 1 - i 11 return -1 12 13 def subchr(string, origchar, newchar): 14 newstr = [] 15 if findchr(string, origchar) == -1: 16 return string 17 for i,chr in enumerate(string): 18 if chr == origchar: 19 newstr.append(newchar) 20 else: 21 newstr.append(string[i]) 22 return ''.join(newstr)
6–13 字符串。string模塊包含三個函數：atoi()，atol()和atof()，它們分別負責把字符串轉換成整數，長整型和浮點型數字。從Python1.5起，Python的內建函數int()，long()，float()也能夠作相同的事了，complex()函數能夠把字符串轉換成複數。(然而1.5以前，這些轉換函數只能工做於數字之上)
string模塊中並無實現一個atoc()函數，那麼你來實現一個atoc()，接受單個字符串作參數輸入：一個表示複數的字符串。例如，'-1.23e+4-5.67j'，返回相應的複數對象。你不能用eval()函數，但可使用complex()函數，並且你只能在以下的限制之下使用complex()：complex(real,imag)的real和imag都必須是浮點值。
1 def atoc(strComp): 2 tmp = strComp 3 tmp = tmp.replace('e+', 'e0') 4 tmp = tmp.replace('e-', 'e0') 5 for i in range(-1, -len(tmp), -1): 6 if tmp[i] in ['+', '-']: 7 break 8 return complex(float(strComp[:i]), float(strComp[i:-1]))
6–14 隨機數。設計一個「石頭，剪子，布」遊戲，有時又叫"Rochambeau"。你小時候可能玩過，下面是規則。你和你的對手，在同一時間作出特定的手勢，必須是下面一種手勢：石頭、剪子、布。勝利者從下面的規則中產生，這個規則自己是個悖論。
(a)布包石頭 (b)石頭砸剪子 (c)剪子剪破布。
在你的計算機版本中，用戶輸入她/他的選項，計算機找一個隨機選項，而後由你的程序來決定一個勝利者或者平手。注意：最好的算法是儘可能少的使用if語句。
1 import random 2 3 def Rochambeau(opt): 4 result = ['tie', 'lose', 'win'] 5 select = {'rock':0, 'shear':1, 'paper':2} 6 macopt = random.randint(0,2) 7 return result[select[opt] - macopt]
6–15 轉換。
(a)給出兩個可識別格式的日期，好比MM/DD/YY或者DD/MM/YY格式，計算出兩個日期間的天數。
(b)給出一我的的生日，計算今後人出生到如今的天數，包括全部的閏月。
(c)仍是上面的例子，計算出到此人下次過生日還有多少天。
1 #!/usr/bin/env python 2 3 import datetime 4 5 #a 6 date1 = raw_input('1st date(D/M/Y): ').strip() 7 date2 = raw_input('2nd date(D/M/Y): ').strip() 8 date1 = date1.split('/') 9 date2 = date2.split('/') 10 date1 = datetime.date(int(date1[2]), int(date1[1]), int(date1[0])) 11 date2 = datetime.date(int(date2[2]), int(date2[1]), int(date2[0])) 12 print 'days: %d' % (date2 - date1).days 13 14 #b 15 birth = raw_input('Your birthday(D/M/Y): ').strip() 16 birth = birth.split('/') 17 birth = datetime.date(int(birth[2]), int(birth[1]), int(birth[0])) 18 today = datetime.date.today() 19 print 'living days: %d' % (today - birth).days 20 21 #c 22 birth = raw_input('Your birthday(D/M/Y): ').strip() 23 birth = birth.split('/') 24 birth = datetime.date(int(birth[2]), int(birth[1]), int(birth[0])) 25 today = datetime.date.today() 26 new_birth = birth.replace(year = today.timetuple().tm_year) 27 if new_birth < today: 28 new_birth = birth.replace(year = today.timetuple().tm_year + 1) 29 print 'next birthday is %d days after today' % (new_birth - today).days
6–16 矩陣。處理矩陣M和N的加和乘操做。
1 #!/usr/bin/env Python 2 'random matrix' 3 4 import random 5 6 m = random.randint(2, 5) 7 n = random.randint(2, 5) 8 p = random.randint(2, 5) 9 10 M1 = [] 11 M2 = [] 12 N = [] 13 14 for i in range(m): 15 tmp1 = [] 16 tmp2 = [] 17 for j in range(n): 18 tmp1.append(random.randint(2, 5)) 19 tmp2.append(random.randint(2, 5)) 20 M1.append(tmp1) 21 M2.append(tmp2) 22 23 for i in range(n): 24 tmp = [] 25 for j in range(p): 26 tmp.append(random.randint(2, 5)) 27 N.append(tmp) 28 29 add_matrix = [] 30 mul_matrix = [] 31 32 for i in range(m): 33 tmp = [] 34 for j in range(n): 35 tmp.append(M1[i][j] + M2[i][j]) 36 add_matrix.append(tmp) 37 38 for i in range(m): 39 tmp = [] 40 for k in range(p): 41 total = 0 42 for j in range(n): 43 total += M1[i][j] * N[j][k] 44 tmp.append(total) 45 mul_matrix.append(tmp)
6–19 多列輸出。有任意項的序列或者其餘容器，把它們等距離分列顯示。由調用者提供數據和輸出格式。例如，若是你傳入100個項並定義3列輸出，按照須要的模式顯示這些數據。這種狀況下，應該是兩列顯示33個項，最後一列顯示34個。你可讓用戶來選擇水平排序或者垂直排序。
1 #!/usr/bin/env Python 2 3 def print_list(userList, column_num, h_or_v): #horizontal or vertical 4 sorted_list = list(userList) 5 sorted_list.sort() 6 listLen = len(sorted_list) 7 lineNum = listLen / column_num 8 remain = listLen % column_num 9 10 if h_or_v == 'h': 11 for i in range(lineNum): 12 for j in range(column_num): 13 print '%2d' % sorted_list[i * column_num + j], 14 print 15 for i in range(remain): 16 for j in range(column_num - 1): 17 print ' ', 18 print sorted_list[lineNum * column_num + i] 19 else: 20 for i in range(lineNum): 21 for j in range(column_num): 22 print '%2d' % sorted_list[i + j * lineNum], 23 print 24 for i in range(remain): 25 for j in range(column_num - 1): 26 print ' ', 27 print sorted_list[lineNum * column_num + i]
- 1. Python核心編程 6.序列：字符串、列表和元組
- 2. Python核心編程（2）——序列：字符串、列表和元組
- 3. python學習記錄——列表、元組
- 4. 《Python基礎教程》學習筆記 – Lesson02：列表和元組
- 5. 《python核心編程》學習筆記
- 6. python核心編程筆記chapter 6
- 7. python第二版6章筆記--序列： 字符串、列表和元 組
- 8. Python編程筆記 - 列表
- 9. Python序列、元組、列表、集合及字典筆記整理
- 10. MOOC python筆記(三) 序列容器：字符串、列表、元組
- 更多相關文章...
- • C# 排序列表（SortedList） - C#教程
- • Scala List(列表) - Scala教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 適用於PHP初學者的學習線路和建議
-
每一个你不满意的现在，都有一个你没有努力的曾经。