python数据结构之列表和元组（list/tuple）

列表和元组

1.数据结构：通过某种方式组织在一起的数据元素的集合。

数据元素：数字、字符、其他数据结构

2.序列：python中，最基本的数据结构是序列，序列中每个元素被分配一个序号=元素位置=索引

python中：→→，由0开始计数；←←，由-1开始计数。

1.序列预览

1.1序列、列表、元组

python中包含6种内建（即，由语法规定存在的）的序列，列表、元组、字符串、Unicode字符串、xrange对象、buffer对象。

列表和元组的主要区别在于，列表可以修改，元组则不能。也就是说，如果要根据要求来添加元素，那么列表可能会更好用。而出于某些原因，序列不能修改的时候，使用元组则更为合适。

1.2表达序列

列表的各个元素通过逗号分隔，写在方括号中。如：

>>> Edward=['Edward Waston',42]

序列中的包含：

>>> John=['John Waston',42]
>>> Sherlock=['Sherlock Holmes',41]
>>> database=[John,Sherlock]
>>> database
[['John Waston', 42], ['Sherlock Holmes', 41]]

2.通用序列操作

所有序列类型都可以进行某些特定的操作：

-索引(indexing)

-分片( sliceing)

-加(adding)

-检查某个元素是否属于序列的成员(成员资格)

-计算序列长度、找出最大元素和最小元素的内建函数。

2.1索引

可以通过索引获取元素。eg2.1-1:

'''输入年、月(1-12的数字)、日(1-31)，然后打印出相应日期的月份名称，等'''
# 根据给定的年月日以数字形式打印出日期
months=[
'January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December']
#以1-31的数字作为结尾的列表
days=
['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+ days[day_number-1]

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

字符串字面值(就此而言，其他序列字面量亦可)能够直接使用索引。eg：

>>> 'hello'[0]
'h'
>>> ['hello'][0]
'hello'
----------
'''如果一个函数调用返回一个序列，那么可以直接对返回结果进行索引操作。'''
>>> five=raw_input('year:')[4]
year:56563
>>> five
'3'

2.2分片

分片操作可以用来访问一定范围内的元素。对于提取序列的一部分是很有用的。

分片操作的实现需要提供两个索引作为边界，第1个索引是需要提取部分的第1个元素的编号，而最后的索引则是分片之后剩下部分的第1个元素的编号。

分片通过冒号相隔的两个索引来实现，eg：

>>> tag = '<a href="https://www.baidu.com"></a>'
>>> tag[9:30]
'https://www.baidu.com'
>>> tag[21:-10]
'baidu'  #第1个索引的元素是包含在分片内的，而第2个则不包含在分片内。

1.分片方法

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:]    #两个索引都置空
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:]   #置空第二个索引
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:10]   #置空第一个索引
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[5:4] #最左边的索引比它右边的晚出现在序列中，结果就是空序列
[]

2.步长

分片的开始和结束点需要进行指定，另外一个参数一一步长(step length)——通常都是隐式设置的。

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[0:10:1] #步长为1（默认为1）
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2] #步长为2
[1, 3, 5, 7, 9]
>>> numbers[::4]    #省略索引
[1, 5, 9]
>>> numbers[::-3]   #步长为负数，即从右向左提取元素，步长不能为0
[10, 7, 4, 1]

2.3序列加法

两种相同类型的序列才能进行连接操作。

>>> ['John']+['Waston']
['John', 'Waston']
>>> 'Hello,'+'World!'
'Hello,World!'

2.4乘法

用数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列将被重复x次。

None、空列表和初始化

空列表[] 一一里面什么东西都没有。

如何创建一个占用元素空间，却不包括任何有用内容的列表?——None。None 是一个python的内建值，它的确切含意是”这里什么也没有”。

>>> none=[None]*10  #[None]必须首字母大写
>>> none
[None, None, None, None, None, None, None, None, None, None]

2.5 成员资格(in)

为了检查一个值是否在序列中，可以使用in运算符。in运算符检查某个条件是否为真，然后返回相应的值：条件为真返回True ，条件为假返回False。这样的运算符叫做布尔运算符，而真值则叫做布尔值。

例：

>>> permissions='abcdefg'
>>> 'a' in permissions
True
>>> 'x' in permissions
False

2016.11.16

2.6长度、最小值和最大值

分别为内建函数len()，min()，max()。

>>> numbers=[1,25,68,24,100,5868]
>>> len(numbers)
6
>>> max(numbers)
5868
>>> min(numbers)
1
# max函数和min函数的参数井不是一个序列，而是以多个数字直接作为参数
>>> max(1,-5)
1
>>> min(1,-3)
-3

3.列表

列表（list函数）的优点：

1.内容可变的（mutable）

2.存在很多有用的、专门的方法（调用，对象.方法(参数)）：

列表可用的方法：

·append，用于在列表末尾增加新的对象，直接修改原列表

·count，统计某个元素在列表中出现的次数

·extend，在列表的末尾一次性追加*另一个序列中的多个值*

与连接操作不同的是：extend方法修改了被扩展的序列，而连接操作则不然，它会返回一个全新的列表（例a+b，则连接操作创建了一个包含了a和b副本的新列表）

·index，用于从列表中找出某个值第一个匹配项的索引位置

·insert，用于将对象插入到列表中。例如a.insert(3,’ok’)相当于a[3:3]=’ok’

·pop，移除列表中的一个元素(默认是最后一个) ，并且返回该元素的值。例如x.pop()，x.pop(2)

实现数据结构栈（后进先出）——pop和append;

实现先进先出——pop和insert(0,…)

·remove，用于移除列表中某个值的第一个匹配项，不返回值。

·reverse，将列表中的元素反向存放，不返回值。

·sort，在原位置对列表进行排序，在”原位置排序”意味着改变原来的列表，从而让其中的元素能按一定的顺序排列。如果想把一些元素按相反的顺序排列，可以先使用sort (或者sorted) ，然后再调用reverse方法，或者直接使用reverse参数。

方棒，②或者也可以使用reverse参数

>>> a=[2,5,6,9,1,2,5,3,88,56]
>>> a.sort()
>>>a
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]

#========↓a、b引用同一个对象↓=========

>>> a=[2,5,6,9,1,2,5,3,88,56]
>>> b=a         #将a赋值给b，会导致a,b同时引用同一个列表
>>> b.sort()    #对b排序，同时也会对a排序
>>> b
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]
>>> a
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]

#=======↓a.sort()的值赋给b↓=======

>>> a=[2,5,6,9,1,2,5,3,88,56]
>>> b=a.sort()     #sort方法修改了a，却返回了空值
>>> print a
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]
>>> print b
None

#=======↓对a排序却不改变a的值↓=======

>>> a=[2,5,6,9,1,2,5,3,88,56]
>>> b=a[:]     #将a的副本赋值给b
>>> b.sort()   #对b排序，a的值却没有改变
>>> b
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]
>>> a
[2, 5, 6, 9, 1, 2, 5, 3, 88, 56]

#=======↓对a排序却不改变a的值↓=======

>>> a=[2,5,6,9,1,2,5,3,88,56]
>>> b=sorted(a)
>>> b
[1, 2, 2, 3, 5, 5, 6, 9, 56, 88]
>>> a
[2, 5, 6, 9, 1, 2, 5, 3, 88, 56]

·高级排序——内建函数cmp

#======↓cmp(x,y)基础用法↓======

>>> cmp(1,1)       #x=y，返回0
0
>>> cmp(32,23)     #x<y，返回1
1
>>> cmp(23,32)     #x>y，返回-1
-1

#======↓sort和cmp↓======

>>>> numbers=[9,5,2,7]
>>> numbers.sort(cmp)
>>> numbers
[2, 5, 7, 9]

#======↓sort的关键字参数key、reverse↓======

>>> x = ['aardvark','abalone ','acme','add','aerate']
>>> x.sort(key=len)  #key必须提供一个在排序过程中使用的的键函数——len，为每个元素创建一个键，然后所有元素根据键来排序。
>>> x
['add', 'acme', 'aerate', 'aardvark', 'abalone ']
>>> x.sort(reverse=True)   #reverse=True，反向排序，reverse是布尔值
>>> x
['aerate', 'add', 'acme', 'abalone ', 'aardvark']
>>>

4.元组:不可变序列

list可以修改，但元组（tuple）不能修改，字符串也不能修改。

#创建元组的语法→用逗号分隔了一些值，那么你就自动创建了元组
#======↓逗号分隔↓======
>>> 1,2,3
(1, 2, 3)
#======↓圆括号→元组↓======
>>> a=(1,2,3)
>>> a
(1, 2, 3)
#======↓空元组↓======
>>> ()
()
#======↓只有1个值的元组↓======
>>> 42,      #必须有逗号
(42,)
#======↓没有逗号和有逗号的区别↓======
>>> 42
42
>>> 42,
(42,)
>>> 3*42
126
>>> 3*42,   #乘法的优先级比较高
(126,)
>>> 3*(42,)
(42, 42, 42)

4.1 tuple 函数

以一个序列作为参数井把它转换为元组。

>>> tuple([1,[1,2]]) #把一个列表转换为元组
(1, [1, 2])
>>> tuple('123')   #把一个字符串转换为元组
('1', '2', '3')
>>> tuple((1,2,3))  #如果参数就是元组，那么该参数就会被原样返回:
(1, 2, 3)

4.2元组的基本操作