Python核心编程--学习笔记--6--序列（下）列表、元组
11 列表
类似于C语言的数组，但是列表可以包含不同类型的任意对象。列表是可变类型。
创建列表——手动赋值、工厂函数：
>>> 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、连接操作符+、重复操作符* 都适用于列表。有几个要注意的点：
>>> 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 列表解析
列表没有自己专门的操作符，但是有自己专属的列表解析：
>>> [ 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码值比较，数字永远小于字符串。
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)这个程序有一个很大的问题，比如输入6、12、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]