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中没有用于列表的专用内建函数，但是列表类型有自己的类方法。

　　列表是可变类型，这些方法直接在原列表上进行修改，所以没有返回值（相比字符串就必须返回新对象）：

 list.append(obj)　　#向列表中添加一个对象obj
 list.count(obj) 　　#返回一个对象obj在列表中出现的次数
 list.extend(seq)　　#把序列seq的元素作为列表元素添加到列表中
 list.index(obj, i=0, j=len(list)) #返回第一个值为obj的下标，不存在则引发ValueError异常
 list.insert(index, obj)  #在索引值为index的位置插入对象obj
 list.pop(index=-1)　　　　#删除并返回指定位置的对象，默认是最后一个对象
 list.remove(obj)  　　　　#从列表中删除对象obj
 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没有专门用于元组的操作符和内建函数，元组类型只有两个方法——统计和查找：

 tuple.count(obj)                     #返回一个对象obj在元组中出现的次数
 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 相关模块

　　与序列类型相关的模块：

 数组                   #一种受限制的可变序列类型，要求所有的元素必须都是相同的类型
 copy                  #提供浅拷贝和深拷贝的能力
 operator              #包含函数调用形式的序列操作符，比如operator.concat(m,n)就相当于连接操作(m+n)
 re                    #Perl风格的正则表达式查找(和匹配);见第 15 章
 StringIO/cStringIO    #把长字符串作为文件来操作，比如read()、seek()函数等，C版的更快一些，但是不能被继承
 textwrap              #用作包裹/填充文本的函数，也有一个类
 types                 #包含Python支持的所有类型
 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一样，不过要用字典序从大到小排列之。

 #!/usr/bin/env Python

 dict_sorted_list = []
 numbers = raw_input('Enter the numbers separated by space: ').split()

 for x in sorted(numbers, reverse = True):
     dict_sorted_list.append(int(x))

 for i,x in enumerate(numbers):
     numbers[i] = int(x)

 sorted_list = sorted(numbers, reverse = True)

 print 'orignal input:', numbers
 print '       sorted:', sorted_list
 print '  dict sorted:', dict_sorted_list

6-3

6–5 字符串

(a)输入一个字符串，逐字符显示。且每次都向前向后多显示一个字符。
(b)通过扫描来判断两个字符串是否匹配(不能使用比较操作符或者cmp()内建函数)。附加题：在你的方案里加入大小写区分。
(c)判断一个字符串是否重现(后面跟前面的一致)。附加题：在处理除了严格的回文之外，加入对例如控制符号和空格的支持。
(d)接受一个字符，在其后面加一个反向的拷贝，构成一个回文字符串。

 #!/usr/bin/env Python

 mystr = raw_input('Enter your string: ')
 mylen = len(mystr)

 if mylen == 0:
     print 'input none'
 elif mylen == 1:
     print mystr
 else:
     for i in range(mylen):
         if i == 0:
             print mystr[0], mystr[1]
         elif i == mylen - 1:
             print mystr[i - 1], mystr[i]
         else:
             print mystr[i - 1], mystr[i], mystr[i + 1]

6-5a

 #!/usr/bin/env Python

 mystr1 = raw_input('1st string: ').strip()
 mystr2 = raw_input('2nd string: ').strip()
 mylen1 = len(mystr1)
 flag   = True

 if mylen1 - len(mystr2):
     flag = False
 else:
     for i in range(mylen1):
         if ord(mystr1[i]) - ord(mystr2[i]):
             flag = False
             break

 if flag:
     print 'equal'
 else:
     print 'not equal'

6-5b

 #!/usr/bin/env Python

 mystr = raw_input('Enter your string: ').strip()
 mylen = len(mystr)
 flag  = True

 for i in range(mylen/2):
     if mystr[i] != mystr[mylen - 1 - i]:
         flag = False
         break

 if flag:
     print 'is palindrome'
 else:
     print 'not palindrome'

6-5c

 #!/usr/bin/env Python

 mystr = raw_input('Enter your string: ').strip()
 palin = mystr + mystr[::-1]
 print palin

6-5d

6–6 字符串。创建一个string.strip()的替代函数：接受一个字符串，去掉它前面和后面的空格。（如果使用string.*strip()函数那本练习就没有意义了）

 #!/usr/bin/env Python

 mystr = raw_input('Enter your string: ')

 for beg,val in enumerate(mystr):
     if val != ' ' and val != '\t':
         break

 for end,val in enumerate(reversed(mystr)):
     if val != ' ' and val != '\t':
         break

 end = len(mystr) - 1 - end

 mystrip = mystr[beg:end+1]
 print mystrip

6-6

6–7 调试。如下例代码：

(a)研究这段代码并描述这段代码想做什么。在所有的(#)处都要填写你的注释。

(b)这个程序有一个很大的问题，比如输入6、12、20、30等它会死掉，实际上它不能处理任何的偶数，找出原因。

(c)修正(b)中提出的问题。

 #!/usr/bin/env Python

 #输入一个整数
 num_str = raw_input('Enter a number: ')

 #将输入的转换为整数对象
 num_num = int(num_str)

 #生成一个列表，范围为[1, num_num]，并打印列表
 fac_list = range(1, num_num + 1)
 print "BEFORE:", fac_list

 #列表下标
 i = 0

 #遍历列表
 while i < len(fac_list):
     #如果输入的数能被当前元素整出，则删除该元素
     if num_num % fac_list[i] == 0:
         del fac_list[i]

     #下标前进1
     i = i + 1

 print "AFTER:", fac_list

6-7a

(b)第23行，当删除元素后，下标已经指向了新元素，再前进1就跳过了一个元素。

(c)对19行的if加一个else，把第23行挂在else之下即可。

6–8 列表。给出一个整数值，返回代表该值的英文，比如输入89返回"eight-nine"。附加题：能够返回符合英文语法规则的形式，比如输入“89”返回“eighty-nine”。本练习中的值限定在[0, 1000]。

 #!/usr/bin/env python 

 single_digits = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
         'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen']
 tens_digits = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']

 while True:
     num = int(raw_input('Enter a number (0, 1000): '))
     if 0 < num < 1000:
         break
     else:
         print 'Input error!'

 #no syntax
 result = ''
 tmpnum = num
 while tmpnum:
     result = single_digits[tmpnum % 10] + '-' + result
     tmpnum /= 10

 print result[:-1]

 #syntax
 result = ''
 tmpnum = num
 if tmpnum >= 100:
     result = '-' + single_digits[tmpnum / 100] + ' hundred'
     tmpnum %= 100

 if 0 < tmpnum <= 19:
     result += '-' + single_digits[tmpnum]
 elif 20 <= tmpnum <= 99:
     result += '-' + tens_digits[tmpnum / 10 - 2]
     if tmpnum % 10:
         result += '-' + single_digits[tmpnum % 10]

 print result[1:]

6-8

6–10 字符串。写一个函数，返回一个跟输入字符串相似的字符串，要求字符串的大小写反转。比如，输入"Mr.Ed"，应该返回"mR.eD"作为输出。

 #!/usr/bin/env python 

 import string

 mystr = raw_input('Enter your string: ')
 chrlist = list(mystr)

 for idx in range(len(mystr)):
     if chrlist[idx] in string.lowercase:
         chrlist[idx] = chrlist[idx].upper()
     elif chrlist[idx] in string.uppercase:
         chrlist[idx] = chrlist[idx].lower()

 print ''.join(chrlist)

6-10

6–11 转换。(a)创建一个从整数到IP地址的转换程序，如下格式：WWW.XXX.YYY.ZZZ  (b)更新你的程序，使之可以逆转换。

 #!/usr/bin/env python 

 ipnum = input('Enter a number: ')
 ipadd = raw_input('Enter an ip address: ').strip()

 print 'int -> ip address'
 ips = []
 for i in range(24, -1, -8):
     ips.append(str( (ipnum >> i) & 0xFF ))
 print '%d -> %s' % (ipnum, '.'.join(ips))

 print 'ip address -> int'
 ipint = 0
 for i,ipstr in enumerate(ipadd.split('.')):
     ipint += int(ipstr) << ((3 - i) * 8)
 print '%s -> %d' % (ipadd, ipint)

6-11

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()类似，不同的是，如果找到匹配的字符就用新的字符替换原先字符。返回修改后的字符串。

 def findchr(string, char):
     for i,chr in enumerate(string):
         if chr == char:
             return i
     return -1

 def rfindchr(string, char):
     for i,chr in enumerate(reversed(string)):
         if chr == char:
             return len(string) - 1 - i
     return -1

 def subchr(string, origchar, newchar):
     newstr = []
     if findchr(string, origchar) == -1:
         return string
     for i,chr in enumerate(string):
         if chr == origchar:
             newstr.append(newchar)
         else:
             newstr.append(string[i])
     return ''.join(newstr)

6-12

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都必须是浮点值。

 def atoc(strComp):
     tmp = strComp
     tmp = tmp.replace('e+', 'e0')
     tmp = tmp.replace('e-', 'e0')
     for i in range(-1, -len(tmp), -1):
         if tmp[i] in ['+', '-']:
             break
     return complex(float(strComp[:i]), float(strComp[i:-1]))

6-13

6–14 随机数。设计一个“石头，剪子，布”游戏，有时又叫"Rochambeau"。你小时候可能玩过，下面是规则。你和你的对手，在同一时间做出特定的手势，必须是下面一种手势：石头、剪子、布。胜利者从下面的规则中产生，这个规则本身是个悖论。

(a)布包石头 (b)石头砸剪子 (c)剪子剪破布。

在你的计算机版本中，用户输入她/他的选项，计算机找一个随机选项，然后由你的程序来决定一个胜利者或者平手。注意：最好的算法是尽量少的使用if语句。

 import random

 def Rochambeau(opt):
     result = ['tie', 'lose', 'win']
     select = {'rock':0, 'shear':1, 'paper':2}
     macopt = random.randint(0,2)
     return result[select[opt] - macopt]

6-14

6–15 转换。

(a)给出两个可识别格式的日期，比如MM/DD/YY或者DD/MM/YY格式，计算出两个日期间的天数。 
(b)给出一个人的生日，计算从此人出生到现在的天数，包括所有的闰月。 
(c)还是上面的例子，计算出到此人下次过生日还有多少天。

 #!/usr/bin/env python 

 import datetime

 #a
 date1 = raw_input('1st date(D/M/Y): ').strip()
 date2 = raw_input('2nd date(D/M/Y): ').strip()
 date1 = date1.split('/')
 date2 = date2.split('/')
 date1 = datetime.date(int(date1[2]), int(date1[1]), int(date1[0]))
 date2 = datetime.date(int(date2[2]), int(date2[1]), int(date2[0]))
 print 'days: %d' % (date2 - date1).days

 #b
 birth = raw_input('Your birthday(D/M/Y): ').strip()
 birth = birth.split('/')
 birth = datetime.date(int(birth[2]), int(birth[1]), int(birth[0]))
 today = datetime.date.today()
 print 'living days: %d' % (today - birth).days

 #c
 birth = raw_input('Your birthday(D/M/Y): ').strip()
 birth = birth.split('/')
 birth = datetime.date(int(birth[2]), int(birth[1]), int(birth[0]))
 today = datetime.date.today()
 new_birth = birth.replace(year = today.timetuple().tm_year)
 if new_birth < today:
     new_birth = birth.replace(year = today.timetuple().tm_year + 1)
 print 'next birthday is %d days after today' % (new_birth - today).days

6-15

6–16 矩阵。处理矩阵M和N的加和乘操作。

 #!/usr/bin/env Python
 'random matrix'

 import random

 m = random.randint(2, 5)
 n = random.randint(2, 5)
 p = random.randint(2, 5)

 M1 = []
 M2 = []
 N  = []

 for i in range(m):
     tmp1 = []
     tmp2 = []
     for j in range(n):
         tmp1.append(random.randint(2, 5))
         tmp2.append(random.randint(2, 5))
     M1.append(tmp1)
     M2.append(tmp2)

 for i in range(n):
     tmp = []
     for j in range(p):
         tmp.append(random.randint(2, 5))
     N.append(tmp)

 add_matrix = []
 mul_matrix = []

 for i in range(m):
     tmp = []
     for j in range(n):
         tmp.append(M1[i][j] + M2[i][j])
     add_matrix.append(tmp)

 for i in range(m):
     tmp = []
     for k in range(p):
         total = 0
         for j in range(n):
             total += M1[i][j] * N[j][k]
         tmp.append(total)
     mul_matrix.append(tmp)

6-16

6–19 多列输出。有任意项的序列或者其他容器，把它们等距离分列显示。由调用者提供数据和输出格式。例如，如果你传入100个项并定义3列输出，按照需要的模式显示这些数据。这种情况下，应该是两列显示33个项，最后一列显示34个。你可以让用户来选择水平排序或者垂直排序。

 #!/usr/bin/env Python

 def print_list(userList, column_num, h_or_v):  #horizontal or vertical
     sorted_list = list(userList)
     sorted_list.sort()
     listLen = len(sorted_list)
     lineNum = listLen / column_num
     remain  = listLen % column_num

     if h_or_v == 'h':
         for i in range(lineNum):
             for j in range(column_num):
                 print '%2d' % sorted_list[i * column_num + j],
             print
         for i in range(remain):
             for j in range(column_num - 1):
                 print '  ',
             print sorted_list[lineNum * column_num + i]
     else:
         for i in range(lineNum):
             for j in range(column_num):
                 print '%2d' % sorted_list[i + j * lineNum],
             print
         for i in range(remain):
             for j in range(column_num - 1):
                 print '  ',
             print sorted_list[lineNum * column_num + i]

6-19