注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

互联网产品经理的窝

梦想社:一个人为了梦想,始终没有停下自己的脚步

 
 
 

日志

 
 

《Python基础教程》学习笔记之[D2]列表和元组  

2012-05-09 14:39:58|  分类: python |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

第二章   序列

 

1. 序列——python最基本的数据结构

Python代码 
  1. >>> edward = ['Edward Gumby'42]  
  2. >>> john = ['John Smith'50]  
  3. >>> database = [edward, john]  
  4. >>> database  
  5. [['Edward Gumby'42], ['John Smith'50]]  

 

 2. 序列操作

(1)索引

Python代码 
  1. >>> greeting = 'Hello'  
  2. >>> greeting[0]    #从左边开始计数,从0开始依次递增  
  3. 'H'  
  4. >>> greeting[4]  
  5. 'o'  
  6. >>> greeting[-1]  #从右边开始计数,从-1开始依次递减  
  7. 'o'  
  8. >>> greeting[-5]  
  9. 'H'  
  10. >>> 'Hello'[1]  #对字符串直接使用索引  
  11. 'e'  
  12. >>> fourth = raw_input('Year: ')[3]  
  13. Year: 2011  
  14. >>> fourth  
  15. '1'  

 

   应用索引的一个完整示例

Python代码 
  1. #根据给定的年月日以数字形式打印日期  
  2. months = ['January''February''March''April''May''June''July',  
  3.           'August''Semptember''October''November''December']  
  4. #以1~31的数字作为结尾的列表  
  5. endings = ['st''nd''rd'] + 17 * ['th']\   #"\"表示该行未完  
  6.          + ['st''nd''rd'] + 7 * ['th']\  
  7.          + ['st']  
  8. year = raw_input("Year: ")  
  9. month = raw_input("Month(1-12): ")  
  10. day = raw_input("Day(1-31): ")  
  11. month_number = int(month)  
  12. day_number = int(day)  
  13. #将月份和天书减1,以获得正确的索引  
  14. month_name = months[month_number - 1]  
  15. day_name = day + endings[day_number - 1]  
  16.   
  17. print month_name + ' ' + day_name + ',' + year  
  18.   
  19. #运行结果  
  20. Year: 2011  
  21. Month(1-12): 9  
  22. Day(1-31): 5  
  23. Semptember 5th,2011  

 

(2)分片

Python代码 
  1. >>> numbers = [12345678910]   #索引左边从0开始递增,右边从-1开始递减  
  2. >>> numbers[7:10]     #(1)开始点的元素包含在结果内,而不包含结束点元素  
  3. [8910]  
  4. >>> numbers[-3:-1]    #同样也可使用负数来表示,但因不含结束点元素,所以无法得到与(1)同样效果  
  5. [89]  
  6. >>> numbers[-3:0]     #开始点索引比结束点索引晚出现在序列中,结果为空序列,倒数第三个比第一个数出现晚  
  7. []  
  8. >>> numbers[-3:]       #与(1)效果相同,若要包括序列结尾元素,只需置空结束点索引即可。  
  9. [8910]  
  10. >>> numbers[:3]        #同样,可将开始点索引置空  
  11. [123]  
  12. >>> numbers[:]          #均置空,实现序列复制  
  13. [12345678910]   
  14. #步长  
  15. >>> numbers[0:10:1]    #默认情况下步长为1  
  16. [12345678910]  
  17. >>> numbers[0:10:2]    #步长为2  
  18. [13579]  
  19. >>> numbers[::2]    #(2)开始点和结束点为空时,默认从开头取至结尾[1, 3, 5, 7, 9]  
  20. >>> numbers[10:0:-1]   #步长可以为负数,但要保证开始点索引比结束点大  
  21. [1098765432]  
  22. >>> numbers[10:0:-2]  
  23. [108642]  
  24. >>> numbers[::-2]   #同(2),但因为从右往左,所以开始点为空默认从序列头部10,结束点为空默认为尾部0  
  25. [108642]  
  26. >>> numbers[10::-2]  #同理  
  27. [108642]  
  28. >>> numbers[:0:-2]  #同理  
  29. [108642]  

 

(3)加法——只有同类型的序列才可以相加(连接)

Python代码 
  1. >>> [123] + [456]  
  2. [123456]  
  3. >>> "Hello. " + "world!"  
  4. 'Hello. world!'  
  5. >>> [123] + "world!"  
  6.   
  7. Traceback (most recent call last):  
  8.   File "<pyshell#25>", line 1in <module>  
  9.     [123] + "world!"  
  10. TypeError: can only concatenate list (not "str") to list  

 

(4)序列乘以一个数n,生成新序列,重复原序列n次。

Python代码 
  1. >>> "python" * 5  
  2. 'pythonpythonpythonpythonpython'  
  3. >>> [42] * 5  
  4. [4242424242]  
  5. >>> [None] * 5    #占用5个元素的空间,却不包含任何内容,None注意首字母大写  
  6. [NoneNoneNoneNoneNone]  

 

    乘法的一个实例

Python代码 
  1. #以正确的宽度在居中的”盒子“内打印一个句子  
  2.   
  3. sentence = raw_input("Sentence: ")  
  4. screen_width = 80  
  5. text_width = len(sentence)  #len():获取序列长度  
  6. box_width = text_width + 6  
  7. left_margin = (screen_width - box_width) // 2  #"//"整除,使得box在screen中居中  
  8.   
  9. print  
  10. print ' ' * left_margin + '+' + '-' * (box_width - 2) + '+'  
  11. print ' ' * left_margin + '|' + ' ' * (box_width - 2) + '|'  
  12. print ' ' * left_margin + '|' + '  ' + sentence + '  |'  
  13. print ' ' * left_margin + '|' + ' ' * (box_width - 2) + '|'  
  14. print ' ' * left_margin + '+' + '-' * (box_width - 2) + '+'  
  15. print  
  16.    
  17. #显示结果  
  18. Sentence: Hello world  
  19.   
  20.                                +---------------+  
  21.                                |               |  
  22.                                |  Hello world  |  
  23.                                |               |  
  24.                                +---------------+  

 

(5)成员资格——检查一个值是否存在于序列中

Python代码 
  1. >>> permission= 'rw'     
  2. >>> 'w' in test    #可用于检查文件是否可读写  
  3. True  
  4. >>> 's' in test  
  5. False  
  6. >>> users = ['mlh''foo''bar']  
  7. >>> raw_input("Enter your name: "in users  #检查用户是否在列表中  
  8. Enter your name: mlh  
  9. True  
  10. >>> 'test' in 'yourtest'  #直接检查  
  11. True  

 

   完整示例

Python代码 
  1. #检查用户名和PIN码  
  2. database = [  
  3.     ['albert''1234'],  
  4.     ['dilbert''2345'],  
  5.     ['simith''3456'],  
  6.     ['johns''4567']  
  7.     ]  
  8. username = raw_input("user name: ")  
  9. pin = raw_input("PIN code: ")  
  10. if [username, pin] in database: print "Access granted"  
  11. elseprint "Access rejected"  
  12.   
  13. #运行结果  
  14.  >>>   
  15. user name: alber  
  16. PIN code: 1234  
  17. Access rejected  
  18. >>> ================================ RESTART ================================  
  19. >>>   
  20. user name: albert  
  21. PIN code: 1234  
  22. Access granted  

 

(5)len(), max(), min()

Python代码 
  1. >>> numbers = [235]  
  2. >>> len(numbers)  
  3. 3  
  4. >>> max(numbers)  
  5. 5  
  6. >>> min(numbers)  
  7. 2  
  8. >>> max(2,4,9)  
  9. 9  
  10. >>> min(145)  
  11. 1  

 

3. 列表——可进行修改

   因为字符串不能被修改,所以将字符串转换为列表后进行修改

(1)列表操作

Python代码 
  1. >>> list("Hello")   #list()将字符串转为列表  
  2. ['H''e''l''l''o']  
  3.   
  4. >>> x = [111]  
  5. >>> x[1] = 2    #根据索引赋值,直接修改内容  
  6. >>> x  
  7. [121]  
  8.   
  9. >>> del x[2]  #del删除元素  
  10. >>> x  
  11. [12]  
  12.   
  13. >>> name = list('Perl')  
  14. >>> name  
  15. ['P''e''r''l']  
  16. >>> name[1:] = list('ython')    #使用分片进行赋值,长度可以与原长度不同  
  17. >>> name  
  18. ['P''y''t''h''o''n']  
  19.   
  20. >>> name[0:0] = list('Hello ')  #插入  
  21. >>> name  
  22. ['H''e''l''l''o'' ''P''y''t''h''o''n']  
  23.   
  24. >>> name[0:6] = []   #相当于del  
  25. >>> name  
  26. ['P''y''t''h''o''n']  
  27. #还可以使用步长,负数索引等。  

 

(3)列表方法——与函数的不同,方法是与对象紧密联系的函数

Python代码 
  1. #append()在列表末尾追加元素,它直接修改列表,而不是生成新的列表  
  2. >>> lst = [123]  
  3. >>> lst.append(4)  
  4. >>> lst  
  5. [1234]  
  6.   
  7. #count()统计元素在列表中出现次数  
  8. >>> ['to''be''or''to'].count('to')  
  9. 2  
  10. >>> x = [[1,2], 11, [21, [12]]]  
  11. >>> x.count(1)  
  12. 2  
  13. >>> x.count([1,2])  
  14. 1  
  15.   
  16. #extend()将一个列表B追加到另一个列表A之后,修改原列表A  
  17. >>> a = [123]  
  18. >>> b = [456]  
  19. >>> a.extend(b)   #a列表被修改  
  20. >>> a  
  21. [123456]  
  22.   
  23. >>> a = [123]  
  24. >>> b = [456]  
  25. >>> a + b             #a列表未被修改,生成了一个包含a和b的副本的新列表  
  26. [123456]     #若用a = a + b,效率比extend低  
  27. >>> a  
  28. [123]  
  29.   
  30. >>> a[len(a):] = b   #用分片可以实现对a列表的修改,可读性差  
  31. >>> a  
  32. [123456]  
  33.   
  34. #index()找出匹配项的第一个索引位置  
  35. >>> a = ['1''2''3''1']  
  36. >>> a.index('1')  
  37. 0  
  38.   
  39. #insert()插入  
  40. >>> numbers = [123567]  
  41. >>> numbers.insert(3'four')  #在索引3之前插入,插入到第三个元素之后  
  42. >>> numbers  
  43. [123'four'567]  
  44.   
  45. >>> numbers = [123567]  
  46. >>> numbers[3:3] = ['four']   #分片实现插入,同样在在索引3之前插入,但可读性差  
  47. >>> numbers  
  48. [123'four'567]  
  49.   
  50.   
  51. >>> #pop()移除列表元素(默认最后一个),并返回该元素的值,是唯一一个及修改列表又返回元素值的列表方法  
  52. >>> #可以用pop()构造栈,用append模拟push,先入后出  
  53. >>> x = [123]  
  54. >>> y = x.pop()  
  55. >>> y  
  56. 3                         #输出的是要移除的元素值  
  57. >>> x.append(y)  
  58. >>> x  
  59. [123]  
  60.   
  61. #上述可写成  
  62. >>> x.append(x.pop())   #pop后又加入,相当于不变  
  63. >>> x  
  64. [123]  
  65. >>>   
  66.   
  67.   
  68. #remove()删除第一个匹配项  
  69. >>> x = ['to''be''or''not''to''be']  
  70. >>> x.remove('be')  
  71. >>> x  
  72. ['to''or''not''to''be']  
  73.   
  74.   
  75. #reverse()将列表中元素反向存放  
  76. >>> x = [123]  
  77. >>> x.reverse()  
  78. >>> x  
  79. [321]  
  80.   
  81.   
  82. #sort()对原列表进行排序,原列表发生改变  
  83. >>> x = [462179]  
  84. >>> x.sort()  
  85. >>> x  
  86. [124679]  
  87. >>>   
  88. #如何实现排序副本,并保持原列表不变呢  
  89. #错误方法  
  90. >>> x = [462179]  
  91. >>> y = x.sort()    
  92. >>> print y  
  93. None   #因为sort()无返回值  
  94. #正确方法  
  95. >>> x = [462179]  
  96. >>> y = x[:]   #高效的复制方法,单纯的将x赋值给y是没用的,这用是x、y都指向同一个列表  
  97. >>> y.sort()  
  98. >>> x             #x未发生改变  
  99. [462179]  
  100. >>> y             #只对x的副本y进行了排序  
  101. [124679]  
  102. >>>   
  103. #sorted()另一种获取副本的方法  
  104. >>> x = [462179]  
  105. >>> y = sorted(x)  
  106. >>> x  
  107. [462179]   #x未发生改变  
  108. >>> y  
  109. [124679]   #只对x的副本y进行了排序  
  110. >>> #简单写法  
  111. >>> sorted(x)   #x未变,只对x的副本排序  
  112. [124679]  
  113.   
  114. >>>   
  115. >>> cmp(2,1)  #cmp(x,y),当x>y时,返回正数  
  116. 1  
  117. >>> cmp(1,2)  #当x<y时,返回负数  
  118. -1  
  119. >>> cmp(1,1)  #当x=y时,返回0  
  120. 0  
  121. >>>   
  122. >>> #cmp作为sort的参数????????  
  123. >>> numbers = [293 ,6]  
  124. >>> numbers.sort(cmp)  #不明白???与一般的.sort()有什么区别??  
  125. >>> numbers  
  126. [2369]  
  127. >>>   
  128. >>> #sort()的可选参数,key和reverse  
  129. >>> x = ['ab''abc''a''abcd']  
  130. >>> x.sort(key=len)  #以元素的长度来排序  
  131. >>> x  
  132. ['a''ab''abc''abcd']  
  133. >>>   
  134. >>> x = [462179]  
  135. >>> x.sort(reverse=True)  #反向排序  
  136. >>> x  
  137. [976421]  

 

4. 元组——不可变的序列

   元组用()表示,而列表用[]表示

Python代码 
  1. >>> 123   #用逗号隔开即可创建新元组  
  2. (123)  
  3. >>> (123)  #同上  
  4. (123)  
  5. >>> ()   #空元组  
  6. ()  
  7. >>> 42  #数字  
  8. 42  
  9. >>> 42,  #添加逗号,就变成了只有一个元素的元组  
  10. (42,)  
  11. >>> (42,)   #同上  
  12. (42,)  
  13. >>> (42)  #没有逗号只有括号,同样是数字,而不是元组  
  14. 42  
  15. >>> 3 * (40 + 2)  #数字计算  
  16. 126  
  17. >>> 3 * (40 + 2,)  #元组相乘  
  18. (424242)  
  19.   
  20.   
  21. #tuple()以一序列作为参数,将其转换为元组  
  22. >>> tuple([123])  #列表转换为元组  
  23. (123)  
  24. >>> tuple('abc')   #字符串转换为元组  
  25. ('a''b''c')  
  26. >>> tuple((1,2,3))   #元组转换为元组  
  27. (123)  
  28.   
  29. #一些基本操作  
  30. >>> x = 123  
  31. >>> x[1]   #根据索引取值  
  32. 2  
  33. >>> x[0:2]   #分片,元组分片后仍为元组,而列表分片后仍未列表  
  34. (12)  

 

5. 元组不可修改,与列表相比存在的意义?

   (1)元组可以在映射中当键使用,而列表不可以

   (2)很多内建函数和方法的返回值都是元组

 

6. 总结

   列表和元组都属于序列,列表可以修改,元组不可变。内容比较简单,同样繁琐易忘

 

涉及函数

cmp(x,y)  比较x,y

len(seq)  返回序列长度

list(seq)  序列转为列表

max(args)

min(args)

reversed(seq)  对列表反响迭代

sorted(seq)  返回原列表的排序列表副本   x.sort()   属于方法,而不是函数

tuple(seq)序列转为元组

  评论这张
 
阅读(134)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017