python学习笔记3——第二章 序列

第二章   序列

 

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

>>> edward = ['Edward Gumby', 42]
>>> john = ['John Smith', 50]
>>> database = [edward, john]
>>> database
[['Edward Gumby', 42], ['John Smith', 50]]

 

 2. 序列操作

（1）索引

>>> greeting = 'Hello'
>>> greeting[0]    #从左边开始计数，从0开始依次递增
'H'
>>> greeting[4]
'o'
>>> greeting[-1]  #从右边开始计数，从-1开始依次递减
'o'
>>> greeting[-5]
'H'
>>> 'Hello'[1]  #对字符串直接使用索引
'e'
>>> fourth = raw_input('Year: ')[3]
Year: 2011
>>> fourth
'1'

 

   应用索引的一个完整示例

#根据给定的年月日以数字形式打印日期
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',
          'August', 'Semptember', 'October', 'November', 'December']
#以1~31的数字作为结尾的列表
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)
#将月份和天书减1，以获得正确的索引
month_name = months[month_number - 1]
day_name = day + endings[day_number - 1]

print month_name + ' ' + day_name + ',' + year

#运行结果
Year: 2011
Month(1-12): 9
Day(1-31): 5
Semptember 5th,2011

 

（2）分片

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]   #索引左边从0开始递增，右边从-1开始递减
>>> numbers[7:10]     #（1）开始点的元素包含在结果内，而不包含结束点元素
[8, 9, 10]
>>> numbers[-3:-1]    #同样也可使用负数来表示，但因不含结束点元素，所以无法得到与（1）同样效果
[8, 9]
>>> numbers[-3:0]     #开始点索引比结束点索引晚出现在序列中，结果为空序列，倒数第三个比第一个数出现晚
[]
>>> numbers[-3:]       #与（1）效果相同，若要包括序列结尾元素，只需置空结束点索引即可。
[8, 9, 10]
>>> numbers[:3]        #同样，可将开始点索引置空
[1, 2, 3]
>>> numbers[:]          #均置空，实现序列复制
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
#步长
>>> numbers[0:10:1]    #默认情况下步长为1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]    #步长为2
[1, 3, 5, 7, 9]
>>> numbers[::2]    #（2）开始点和结束点为空时，默认从开头取至结尾[1, 3, 5, 7, 9]
>>> numbers[10:0:-1]   #步长可以为负数，但要保证开始点索引比结束点大
[10, 9, 8, 7, 6, 5, 4, 3, 2]
>>> numbers[10:0:-2]
[10, 8, 6, 4, 2]
>>> numbers[::-2]   #同（2），但因为从右往左，所以开始点为空默认从序列头部10，结束点为空默认为尾部0
[10, 8, 6, 4, 2]
>>> numbers[10::-2]  #同理
[10, 8, 6, 4, 2]
>>> numbers[:0:-2]  #同理
[10, 8, 6, 4, 2]

 

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

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> "Hello. " + "world!"
'Hello. world!'
>>> [1, 2, 3] + "world!"

Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    [1, 2, 3] + "world!"
TypeError: can only concatenate list (not "str") to list

 

（4）序列乘以一个数n，生成新序列，重复原序列n次。

>>> "python" * 5
'pythonpythonpythonpythonpython'
>>> [42] * 5
[42, 42, 42, 42, 42]
>>> [None] * 5    #占用5个元素的空间，却不包含任何内容，None注意首字母大写
[None, None, None, None, None]

 

    乘法的一个实例

#以正确的宽度在居中的”盒子“内打印一个句子

sentence = raw_input("Sentence: ")
screen_width = 80
text_width = len(sentence)  #len()：获取序列长度
box_width = text_width + 6
left_margin = (screen_width - box_width) // 2  #"//"整除，使得box在screen中居中

print
print ' ' * left_margin + '+' + '-' * (box_width - 2) + '+'
print ' ' * left_margin + '|' + ' ' * (box_width - 2) + '|'
print ' ' * left_margin + '|' + '  ' + sentence + '  |'
print ' ' * left_margin + '|' + ' ' * (box_width - 2) + '|'
print ' ' * left_margin + '+' + '-' * (box_width - 2) + '+'
print
 
#显示结果
Sentence: Hello world

                               +---------------+
                               |               |
                               |  Hello world  |
                               |               |
                               +---------------+

 

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

>>> permission= 'rw'   
>>> 'w' in test    #可用于检查文件是否可读写
True
>>> 's' in test
False
>>> users = ['mlh', 'foo', 'bar']
>>> raw_input("Enter your name: ") in users  #检查用户是否在列表中
Enter your name: mlh
True
>>> 'test' in 'yourtest'  #直接检查
True

 

   完整示例

#检查用户名和PIN码
database = [
    ['albert', '1234'],
    ['dilbert', '2345'],
    ['simith', '3456'],
    ['johns', '4567']
    ]
username = raw_input("user name: ")
pin = raw_input("PIN code: ")
if [username, pin] in database: print "Access granted"
else: print "Access rejected"

#运行结果
 >>> 
user name: alber
PIN code: 1234
Access rejected
>>> ================================ RESTART ================================
>>> 
user name: albert
PIN code: 1234
Access granted

 

（5）len(), max(), min()

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

 

3. 列表——可进行修改

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

（1）列表操作

>>> list("Hello")   #list()将字符串转为列表
['H', 'e', 'l', 'l', 'o']

>>> x = [1, 1, 1]
>>> x[1] = 2    #根据索引赋值，直接修改内容
>>> x
[1, 2, 1]

>>> del x[2]  #del删除元素
>>> x
[1, 2]

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[1:] = list('ython')    #使用分片进行赋值，长度可以与原长度不同
>>> name
['P', 'y', 't', 'h', 'o', 'n']

>>> name[0:0] = list('Hello ')  #插入
>>> name
['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']

>>> name[0:6] = []   #相当于del
>>> name
['P', 'y', 't', 'h', 'o', 'n']
#还可以使用步长，负数索引等。

 

（3）列表方法——与函数的不同，方法是与对象紧密联系的函数

#append()在列表末尾追加元素，它直接修改列表，而不是生成新的列表
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

#count()统计元素在列表中出现次数
>>> ['to', 'be', 'or', 'to'].count('to')
2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1

#extend()将一个列表B追加到另一个列表A之后，修改原列表A
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)   #a列表被修改
>>> a
[1, 2, 3, 4, 5, 6]

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b             #a列表未被修改，生成了一个包含a和b的副本的新列表
[1, 2, 3, 4, 5, 6]     #若用a = a + b，效率比extend低
>>> a
[1, 2, 3]

>>> a[len(a):] = b   #用分片可以实现对a列表的修改，可读性差
>>> a
[1, 2, 3, 4, 5, 6]

#index()找出匹配项的第一个索引位置
>>> a = ['1', '2', '3', '1']
>>> a.index('1')
0

#insert()插入
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')  #在索引3之前插入，插入到第三个元素之后
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = ['four']   #分片实现插入，同样在在索引3之前插入，但可读性差
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]


>>> #pop()移除列表元素（默认最后一个），并返回该元素的值，是唯一一个及修改列表又返回元素值的列表方法
>>> #可以用pop()构造栈，用append模拟push，先入后出
>>> x = [1, 2, 3]
>>> y = x.pop()
>>> y
3                         #输出的是要移除的元素值
>>> x.append(y)
>>> x
[1, 2, 3]

#上述可写成
>>> x.append(x.pop())   #pop后又加入，相当于不变
>>> x
[1, 2, 3]
>>> 


#remove()删除第一个匹配项
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']


#reverse()将列表中元素反向存放
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]


#sort()对原列表进行排序，原列表发生改变
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]
>>> 
#如何实现排序副本，并保持原列表不变呢
#错误方法
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort()  
>>> print y
None   #因为sort()无返回值
#正确方法
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x[:]   #高效的复制方法，单纯的将x赋值给y是没用的，这用是x、y都指向同一个列表
>>> y.sort()
>>> x             #x未发生改变
[4, 6, 2, 1, 7, 9]
>>> y             #只对x的副本y进行了排序
[1, 2, 4, 6, 7, 9]
>>> 
#sorted()另一种获取副本的方法
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]   #x未发生改变
>>> y
[1, 2, 4, 6, 7, 9]   #只对x的副本y进行了排序
>>> #简单写法
>>> sorted(x)   #x未变，只对x的副本排序
[1, 2, 4, 6, 7, 9]

>>> 
>>> cmp(2,1)  #cmp(x,y),当x>y时，返回正数
1
>>> cmp(1,2)  #当x<y时，返回负数
-1
>>> cmp(1,1)  #当x=y时，返回0
0
>>> 
>>> #cmp作为sort的参数？？？？？？？？
>>> numbers = [2, 9, 3 ,6]
>>> numbers.sort(cmp)  #不明白？？？与一般的.sort()有什么区别？？
>>> numbers
[2, 3, 6, 9]
>>> 
>>> #sort()的可选参数，key和reverse
>>> x = ['ab', 'abc', 'a', 'abcd']
>>> x.sort(key=len)  #以元素的长度来排序
>>> x
['a', 'ab', 'abc', 'abcd']
>>> 
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)  #反向排序
>>> x
[9, 7, 6, 4, 2, 1]

 

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

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

>>> 1, 2, 3   #用逗号隔开即可创建新元组
(1, 2, 3)
>>> (1, 2, 3)  #同上
(1, 2, 3)
>>> ()   #空元组
()
>>> 42  #数字
42
>>> 42,  #添加逗号，就变成了只有一个元素的元组
(42,)
>>> (42,)   #同上
(42,)
>>> (42)  #没有逗号只有括号，同样是数字，而不是元组
42
>>> 3 * (40 + 2)  #数字计算
126
>>> 3 * (40 + 2,)  #元组相乘
(42, 42, 42)


#tuple()以一序列作为参数，将其转换为元组
>>> tuple([1, 2, 3])  #列表转换为元组
(1, 2, 3)
>>> tuple('abc')   #字符串转换为元组
('a', 'b', 'c')
>>> tuple((1,2,3))   #元组转换为元组
(1, 2, 3)

#一些基本操作
>>> x = 1, 2, 3
>>> x[1]   #根据索引取值
2
>>> x[0:2]   #分片，元组分片后仍为元组，而列表分片后仍未列表
(1, 2)

 

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）序列转为元组