《Python基础教程（第二版）》学习笔记 -> 第二章 列表和元组

本章将引入一个新的概念：数据结构。

数据结构是通过某种方式阻止在一起的数据元素的集合，这些数据元素可以是数字或者字符，设置可以是其他数据结构。

Python中，最基本的数据结构是序列（Sequence）,序列中的每个元素被分配一个序列号--即元素的位置，也称为索引。第一个索引是0，第二个则是1，以此类推，倒数第一个是-1。

 

序列概览

---

　　 Python中包含6中内建的序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。本章节重点内容是：列表和元组。

　　列表和元组的主要区别在于：列表可以修改， 元组则不能。

　　 下面开始举例：

>>> example = ['1','b',3]

>>> example2 = ['test']

>>> test = [example,example2]

>>> test

    [['1', 'b', 3], ['test']]

　　上例是对列表进行赋值操作，列表是用[]来括起来的

 

通用序列操作

---

　　 常用的操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员。除此之外，Python还有计算序列长度，找出最大元素和最小元素的内建函数。

1.  索引
   序列中的所有元素都是有编号的（从0开始递增，0指向第一个元素），示例如下：
   

   >>> test = 'hello'
   
   >>> test[0]
   
   'h'

   下面再例举一个代码实例：

   #define months
   
   months = [
   
       'Jan',
   
       'Feb',
   
       'Mar',
   
       'Apr',
   
       'May',
   
       'Jun',
   
       'Jul',
   
       'Aug',
   
       'Sep',
   
       'Oct',
   
       'Nov',
   
       'Dec'
   
       ]
   
   #define day's endings
   
   endings = ['st','nd','rd'] + 17*['th']\
   
           + ['st','nd','rd'] + 7*['th']\
   
           + ['st']
   
   year = raw_input('Year:')
   
   month = raw_input('Month(1-12):')
   
   day = raw_input('Day(1-31):')
   
   
   
   month_number = int(month)
   
   day_number = int(day)
   
   
   
   month_name = months[month_number - 1]
   
   day_name = day + endings[day_number - 1]
   
   
   
   print month_name +' '+ day_name + ',' + year

   输出结果：

   Year:2013
   
   Month(1-12):12
   
   Day(1-31):26
   
   Dec 26th,2013

    

2. 分片
   先示例：
   

   >>> a = [1,2,3,4,5,6,7,8,9,10]
   
   >>> a[1:5]
   
       [2, 3, 4, 5]

   结合上例，根据上节索引内容可知，分片操作的实现需要提供至少两个索引作为边界，第一个索引的元素是包含在元素分片内的，而第二个则不包含在分片内。

   下面再例举几个实例：
   

   >>> a[-3:-1]
   
       [8, 9]
   
   >>> a[-3:]
   
       [8, 9, 10]
   
   >>> a[:]
   
       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

   更大的步长

   >>> a = [1,2,3,4,5,6,7,8,9,10]
   
   >>> a[1:9:2]
   
       [2, 4, 6, 8]
   
   >>> a[::2]
   
       [1, 3, 5, 7, 9]
   
   >>> a[::-2]
   
       [10, 8, 6, 4, 2]

   进行分片的时候，分片的开始和结束点需要进行指定，而另一个参数 - 步长（step length），通常都是隐式设置的。在普通的分片中，默认步长是1，分片操作就是按照这个步长逐步遍历序列的元素，然后返回开始喝结束点之间的所有元素。

   如果步长是负数，那么就会从右往左提取元素。
   
   

3. 序列相加
   只有两种相同类型的序列才能进行连接操作
   

   >>> a = [1,2]
   
   >>> b = [3,4]
   
   >>> a + b
   
       [1, 2, 3, 4]

    

4. 乘法
   用数字x诚意一个序列会生成新的序列，而在新的序列中，原来的序列会被重复x次，示例如下：
   

   >>> 'Python'*5
   
       'PythonPythonPythonPythonPython'
   
   >>> [5]*5
   
       [5, 5, 5, 5, 5]

    

   下面举一个复杂一点的乘法示例：用程序在屏幕上打印一个由字符组成的“盒子”，而这个“盒子”在屏幕上居中，而且能根据用户输入的句子自动调整大小：
   
   

   sentence = raw_input('please input the sentence:')
   
   screen_width = 80
   
   text_width = len(sentence)
   
   box_width = text_width +6
   
   left_margin = (screen_width - box_width)//2
   
   
   
   print
   
   print ' '*left_margin + '+' + '-'*(box_width-2) + '+'
   
   print ' '*left_margin + '|' + ' '*(box_width-2) + '|'
   
   print ' '*left_margin + '|' + sentence + ' '*(box_width-2-text_width) + '|'
   
   print ' '*left_margin + '|' + ' '*(box_width-2) + '|'
   
   print ' '*left_margin + '+' + '-'*(box_width-2) + '+'
   
   print

   输出结果如下:

   please input the sentence:Python
   
   
   
                                     +----------+
   
                                     |          |
   
                                     |Python    |
   
                                     |          |
   
                                     +----------+

   None、空列表和初始化
   
   空列表可以简单地通过两个中括号进行表示（[]）。
   None是一个Python的内建值，它的确切含义是“这里什么也没有”，因此，如果想初始化一个长度为10的列表，可以按照下面的例子：

   >>> sequence = [None]*10
   
   >>> sequence
   
       [None, None, None, None, None, None, None, None, None, None]

   注意None的首字母大写

5. 成员资格
   为了检查一个值是否在序列中，可以使用 in 运算符。示例如下：
   

   >>> p = [2,3]
   
   >>> 2 in p
   
       True
   
   >>> x = 'Python'
   
   >>> 'm' in x
   
       False

    

6. 长度、最小值 和 最大值
   内建函数len（长度），min（最小值）和max（最大值）。
   示例如下：
   

   >>> python = [1,2,3,4,5]
   
   >>> len(python)
   
       5
   
   >>> max(python)
   
       5
   
   >>> min(python)
   
       1

    

列表

---

 　　上面的例子已经用了很多次列表，下面将会讨论列表不同于元素和字符串的地方：列表时可变的（mutable）——可以改变列表的内容，并且列表有很多有用的、专门的方法。

1. list函数
   因为字符串不能像列表那样被修改，所以有时根据字符串创建列表会很有用，而list函数可以实现这个操作：
   

   >>> list('Python')
   
       ['P', 'y', 't', 'h', 'o', 'n']

   list函数适用于所有类型的序列，而不只是字符串

2. 基本的列表操作
   ①改变列表：元素赋值
   

   >>> a = [1,2,3]
   
   >>> a[1] = 4
   
   >>> a
   
       [1, 4, 3]

    

   ②删除元素
   

   >>> test = ['a','b','c','d']
   
   >>> del test[2]
   
   >>> test
   
   ['a', 'b', 'd']

    

   ③分片赋值
   先示例：
   

   >>> name = list('python')
   
   >>> name[1:] = 'wm'
   
   >>> name
   
   ['p', 'w', 'm']
   
   
   
   >>> names = list('english')
   
   >>> names[1:3] = 'tt'
   
   >>> names
   
   ['e', 't', 't', 'l', 'i', 's', 'h']

   分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素：

   >>> a = ['1','2','3']
   
   >>> a[1:1] = 'test'
   
   >>> a
   
   ['1', 't', 'e', 's', 't', '2', '3']

    

3. 列表方法
   方法是一个与某些对象有紧密联系的函数，对象可能是列表、数字。也可能是字符串或者其他类型的对象。一般来说，方法可以这样进行调用：
   对象.方法（参数）
   
   ① append
   append方法用于在列表末尾追加新的对象：
   

   >>> a = [1,2,3]
   
   >>> a.append(4)
   
   >>> a
   
   [1, 2, 3, 4]

    

   ② count
   count方法统计某个元素在列表出现的次数
   

   >>> test = [1,'a','a',[1,2],[1,[1,2]]]
   
   >>> test.count(1)
   
   1
   
   >>> test.count('a')
   
   2
   
   >>> test.count([1,2])
   
   1

    

   ③ extend
   extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话说，可以用新列表扩展原有的列表：
   

   >>> a = [1,2,3]
   
   >>> b = [4,5,6]
   
   >>> a.extend(b)
   
   >>> a
   
   [1, 2, 3, 4, 5, 6]

   和连接操作，赋值操作对比

   >>> a = [1,2,3]
   
   >>> b = [4,5,6]
   
   >>> a+b
   
   [1, 2, 3, 4, 5, 6]
   
   >>> a
   
   [1, 2, 3]
   
   >>> a = a + b #赋值操作
   
   >>> a
   
   [1, 2, 3, 4, 5, 6]

    

   ④ index
   index方法用于从列表中找出某个值第一个匹配项的索引位置：
   
   

   >>> a = ['a','b','c','d']
   
   >>> a.index('c')
   
   2

   当索引中寻找的匹配项找不到，系统就会报错

   
   ⑤ insert
   insert方法用于将对象插入到列表中：
   

   >>> a = [1,2,3,4,5]
   
   >>> a.insert(3,'Python')
   
   >>> a
   
   [1, 2, 3, 'Python', 4, 5]

    

   ⑥ pop
   pop方法会移除列表中的一个元素（默认是最后一个），并返回该元素的值：
   

   >>> a = [1,2,3]
   
   >>> a.pop()
   
   3
   
   >>> a
   
   [1, 2]

   ⑦ remove

   remove方法用于移除列表中某个值的第一个匹配项
   

   >>> a = [1,2,3,1]
   
   >>> a.remove(1)
   
   >>> a
   
   [2, 3, 1]

    

   ⑧ reverse
   reverse方法将列表中的元素方向存放
   

   >>> a = ['a','b','c']
   
   >>> a.reverse()
   
   >>> a
   
   ['c', 'b', 'a']

    

   ⑨ sort
   sort方法用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单地返回一个已排序的列表副本。
   

   >>> x = [1,6,4,3,9,2]
   
   >>> x.sort()
   
   >>> x
   
   [1, 2, 3, 4, 6, 9]

    

　　4. 元组

　　元组与列表一样，也是一种序列。唯一的不同是元组不能修改。创建元组的语法很简单：
　　

>>> 1,2,3

(1, 2, 3)

>>> (2,3,4)

(2, 3, 4)

>>> ()

()

　　①tuple函数

　　tuple函数的功能与list函数基本是一样的：以一个序列作为参数并把它转换为元组。如果参数是元组，那么该参数就会被原样返回：

　　　　

>>> tuple([1,2,3])

(1, 2, 3)

>>> tuple('abc')

('a', 'b', 'c')

>>> tuple((1,2))

(1, 2)

　　②基本元组操作和序列类似

　　

　　③元组的意义

• 元组可以在映射中当做键来使用，而列表不行
• 元组作为很多内建函数和方法的返回值存在，也就是说你必须对元组进行处理。

小结

---

•  序列：序列是一种数据结构，它包含的元素都进行了编号（从0开始）。典型的序列包括：列表、字符串和元组。
• 成员资格：in操作符
• 方法：现在主要是一些内建的函数

 

 （加快自己的节奏，最近又贪玩了，呵呵下自己）