python基础教程学习笔记 第二章 列表和元组

数据结构是通过某种方式（例如对元素进行编码）组织在一起的数据元素的集合

这些数据元素可以是数字或者字符，甚至可以是其他的数据结构。在python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序号--即元素的位置，也称为索引。

元组除了不能更改之外，其他的性质和列表都很类似。

序列概览

python包含6中内建的序列:列表，元组，字符串，Unicode字符串，buffer对象和xrange对象

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

需要根据要求来添加元素，使用列表。

出于某些原因，序列不能修改的时候，使用元组则更为合适。---技术性，他与python内部的运作方式有关。这也是内建函数可能返回元组的原因。

一般来说，在几乎所有的情况下列表都可以替代元组（元组作为字典的键是，键不可修改，所以不能使用列表）

>>> edwar=['edward gumby',42]

>>> john=['john smith',50]

>>> database=[edwar,john]

>>> database

[['edward gumby', 42], ['john smith', 50]]

python之中还有一种名为容器（container）的数据结构。容器基本上是包含其他对象的任意对象。序列（列表和元组）和映射（字典）是两类主要的容器。

集合不是序列也不是映射的容器类型

通用序列操作

所有序列类型都可以进行某些特定的操作：索引，分片，加，乘以及检查某个元素是否属于序列的成员（成员资格）。计算序列长度，找出最大元素和最小元素的内建函数。

1.索引---从0开始递增

>>> greeting='hello'

>>> greeting[0]

'h'

>>> greeting[-1]

'o'

字符串就是一个由字符组成的序列。

字符串字面值（其他序列字面量亦可）能够直接使用索引，而不需一个变量引用他们

>>> "Hello"[1]

'e'

>>> forth=raw_input('Year: ')[3]

Year: 2005

>>> forth

'5'

eg：

month.py

months=['January','February','March','April','May','June','July','August','September','October','November','December']

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]

ordinal=day+endings[day_number-1]

print month_name+' '+ordinal+','+year

run:

>>>

====================== RESTART: E:/pythonlearn/month.py ======================

Year: 2017

Month(1-12): 4

Day(1-31): 12

April 12th,2017

>>>

2.分片

索引访问单个元素，使用分片操作来访问一定范围内的元素

>>> tag='<a href="http;//www.python.org">Python web site</a>'

>>> tag[9:30]

'http;//www.python.org'

>>> tag[9:40]

'http;//www.python.org">Python w'

>>> tag[32:-4]

'Python web site'

>>>

分片操作的实现需要提供两个索引作为边界，第一个索引的元素是包含在分片内的，第二个则不包括在分片内。

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

>>> numbers[7:10]

[8, 9, 10]

>>> numbers[-3:-1]

[8, 9]

>>>

>>> numbers[-3:0]

[]

>>> numbers[-3:]

[8, 9, 10]

>>> numbers[:3]

[1, 2, 3]

分片中最左边的索引比他右边的晚出现在序列中

eg:

sliceing.py

url=raw_input('Please enter the URL: ')

domain=url[11:-4]

print 'Domain name:'+domain

>>>

==================== RESTART: E:/pythonlearn/sliceing.py ====================

Please enter the URL: http://www.python.org

Domain name:python

>>>

步长 步长2的分片包括开始到结束每隔一个的元素， 步长不能为0，但是步长可以是负数，从右往左提取元素：

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

>>> numbers[0:10:1]

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> numbers[0:10:2]

[1, 3, 5, 7, 9]

>>> numbers[3:6:3]

[4]

>>> numbers[::3]

[1, 4, 7, 10]

>>> numbers[8:3:-1]

[9, 8, 7, 6, 5]

>>> numbers[10:0:-2]

[10, 8, 6, 4, 2]

>>> numbers[0:10:-2]

[]

>>> numbers[::-2]

[10, 8, 6, 4, 2]

>>> numbers[5::-2]

[6, 4, 2]

>>> numbers[:5:-2]

[10, 8]

负数作为步长时，必须让开始点大于结束点。在没有明确指定开始点和结束点的时候，正负数的使用可能会带来一些混淆

对于整数步长，python会从序列的头部开始向右提取元素，知道最后一个元素，而对于负数不成，则是从序列的尾部开始向左提取元素，直到第一元素。

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#34>", line 1, in <module>

  [1,2,3]+'world'

TypeError: can only concatenate list (not "str") to list

>>>

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

4.乘法

用数字x乘以一个序列会生成新的序列。

>>> "python"*5

'pythonpythonpythonpythonpython'

>>> [42]*10

[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

None 空列表和初始化

None使用一个python的内建值

eg：

multiplus.py

sentence=raw_input('Sentence: ')

sceen_width=80

text_width=len(sentence)

box_width=text_width+4

left_margin=(sceen_width-box_width)//2

print

print ' '*left_margin+'+'+'-'*(box_width-2)+'+'

print ' '*left_margin+'| '+' '*text_width +' |'

print ' '*left_margin+'| '+sentence +' |'

print ' '*left_margin+'| '+' '*text_width +' |'

print ' '*left_margin+'+'+'-'*(box_width-2)+'+'

print

run

==================== RESTART: E:/pythonlearn/multiplus.py ====================

Sentence: He's a very naughty boy!

                               +--------------------------+

                               |                          |

                               | He's a very naughty boy! |

                               |                          |

                               +--------------------------+

>>>

5.成员资格

>>> permissions='rw'

>>> 'w' in permissions

True

>>>

 

6长度，最小值和最大值

>>> numbers=[100,34,678]

>>> len(numbers)

3

>>> max(numbers)

678

>>> min(numbers)

34

>>>

>>> max(3,2)

3

>>> min(3,2)

2

 

列表

列表是可变的，可以该表列表的内容，并且列表有很多有用的，专门的方法

list函数

实际上是一种类型而不是函数

>>> list('hello')

['h', 'e', 'l', 'l', 'o']

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

基本的列表操作

列表可以使用所有适用于序列的标准操作，例如索引，分片，连接和乘法。列表是可以i修改的。

改变列表的方法：元素赋值，元素删除，分片赋值以及列表方法 （并不是所有的列表方法都真正地改变列表）

1.改变列表：元素赋值

改变列表是很容易的。赋值语句即可。

>>> x=[1,2,43,33]

>>> x[2]=3

>>> x

[1, 2, 3, 33]

不能为一个位置不存在的元素进行赋值。

2.删除元素

>>> del x[2]

>>> x

[1, 2, 33]

3.分片赋值

分片是一个非常强大的特性，分片赋值操作则更加显示他的强大。

>>> name=list("Pera")

>>> name

['P', 'e', 'r', 'a']

>>> name[2:]=list('ar')

>>> name

['P', 'e', 'a', 'r']

程序可以i一次性为多个元素赋值。可以使用与原序列不等长的序列将分片替换。

>>> name[1:]=list('python')

>>> name

['P', 'p', 'y', 't', 'h', 'o', 'n']

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

>>> numbers=[1,5]

>>> numbers[1:1]=[2,3,4]

>>> numbers

[1, 2, 3, 4, 5]

通过分片赋值删除元素也可

>>> numbers

[1, 2, 3, 4, 5]

>>> numbers[1:4]=[]

>>> numbers

[1, 5]

>>> numbers[1:4:2]

[1, 3]

>>> numbers[1:4:2]=[8,9]

>>> numbers

[1, 8, 2, 9, 4, 5]

列表方法

方法调用：对象.方法（参数）

1.append

append直接修改原来的列表

>>> numbers.append(10)

>>> numbers

[1, 8, 2, 9, 4, 5, 10]

2.count

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

>>> ['to','be','number','one','be'].count('be')

2

>>> x=[[1,2,3],3,2,[1,2],[3]]

>>> x.count(3)

1

>>>

 3.extent

extend方法修改了被扩展的序列，而原始的连接操作则不然，他会返回一个全新的列表：

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

>>> b=[4,5,6]

>>> a.extendp(b)

>>> a.extend(b)

>>> b.append(4)

>>> a

[1, 2, 3, 4, 5, 6]

>>>

>>> a.append(b)

>>> a

[1, 2, 3, 4, 5, 6, [4, 5, 6, 4]]

>>> a.extend(b)

>>> a

[1, 2, 3, 4, 5, 6, [4, 5, 6, 4], 4, 5, 6, 4]

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

>>> b=[4,5,6]

>>> a+b

[1, 2, 3, 4, 5, 6]

>>> a

[1, 2, 3]

原始连接操作中创建一个包含了a和b副本的新列表，a=a+b的操作的效率比extend方法低，不会修改原来的列表

4.index

>>> a

[1, 2, 3]

>>> a.index(2)

1

>>> a.index(4)

Traceback (most recent call last):

  File "<pyshell#111>", line 1, in <module>

  a.index(4)

ValueError: 4 is not in list

5.insert

>>> a.insert(4,5)

>>> a

[1, 2, 3, 5]

>>> a.insert(7,4)

>>> a

[1, 2, 3, 5, 4]

>>> a.insert(0,0)

>>> a

[0, 1, 2, 3, 5, 4]

6.pop 

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

>>> a.pop()

4

>>> a

[0, 1, 2, 3, 5]

>>> a.pop(0)

0

>>> a

[1, 2, 3, 5]

pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法

使用pop方法可以实现一种常见的数据结构--栈，后进先出（LIFO）

>>> x=[1,3,5]

>>> x.append(x.pop())

>>> x

[1, 3, 5]

实现先进先出（FIFO）的队列（queue），

>>> x.insert(0,x.pop(0))

>>> x

[1, 3, 5]

7.remove

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

>>> x=['to','be','or','not','to','be']

>>> x.remove("be")

>>> x

['to', 'or', 'not', 'to', 'be']

>>> x.remove('bee')

Traceback (most recent call last):

  File "<pyshell#132>", line 1, in <module>

  x.remove('bee')

ValueError: list.remove(x): x not in list

remove是一个没有返回值的原位置改变方法。他修改了列表却没有返回值，与pop方法相反。

8.reverse

>>> x=[1,2,3]

>>> x.reverse()

>>> x

[3, 2, 1]

>>> list(reversed(x))

[1, 2, 3]

改变列表但不返回值

reverse函数返回一个迭代器对象，而不是列表

9.sort

sort方法用于在原位置对列表进行排序，改变原来的列表

>>> x=[4,6,3,2,1,9,7]

>>> x.sort() #返回None不能对x.sort()进行赋值

>>> x

[1, 2, 3, 4, 6, 7, 9]

x[:]得到包含了x所有元素的分片，x=y 使x和y指向同一个列表。

>>> x=[4,6,3,2,1,9,7]

>>> y=x[:]

>>> y.sort()

>>> x

[4, 6, 3, 2, 1, 9, 7]

>>> y

[1, 2, 3, 4, 6, 7, 9]

>>> y=x

>>> x=[4,6,3,2,1,9,7]

>>> y=x

>>> y.sort()

>>> y

[1, 2, 3, 4, 6, 7, 9]

>>> x

[1, 2, 3, 4, 6, 7, 9]

sorted函数获取已排序的列表副本的方法

>>> x=[4,6,3,2,1,9,7]

>>> y=sorted(x)

>>> x

[4, 6, 3, 2, 1, 9, 7]

>>> y

[1, 2, 3, 4, 6, 7, 9]

>>> sorted('python')

['h', 'n', 'o', 'p', 't', 'y']

高级排序

cmp内建函数 x>y 1 x<y -1 x==y 0

>>> cmp(42,32)

1

>>> cmp(32,42)

-1

>>> cmp(10,10)

0

>>> numbers=[5,2,9,6]

>>> numbers.sort(cmp)

>>> numbers

[2, 5, 6, 9]

sort 方法有两个可选的参数--key和reverse，关键字参数

>>> x=["sd","34e21","232","232dssa","23ssa"]

>>> x.sort(key=len)

>>> x

['sd', '232', '34e21', '23ssa', '232dssa']

>>> x=[9,3,45,2,1,6]

>>> x.sort(reverse=True)

>>> x

[45, 9, 6, 3, 2, 1]

元组：不可变序列

元组没有像列表一样的方法

>>> 1,2,3

(1, 2, 3)

>>> (1,3,4)

(1, 3, 4)

>>> ()

()

>>> 42

42

>>> 43,

(43,)

>>> (43,)

(43,)

>>> 3*(40+2,)

(42, 42, 42)

>>> a=(1,2,3)

>>> a[2]

3

tuple函数 跟list一样的功能，如果参数是元组则原样返回

tuple并不是真正的函数---而是一种类型

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

(1, 2, 3)

>>> tuple('aaf')

('a', 'a', 'f')

>>> tuple((1,2,2))

(1, 2, 2)

基本元组操作

创建元组和访问元组元素

使用元组的场景：

元组可以在映射（和集合的成员）中当做键使用-而列表则不行

元组作为很多内建函数和方法的返回值存在，也就是说你必须对元组进行处理。

序列是一种数据结构，它包含的元素都进行了编号（从0开始）。典型的序列包括列表，字符串和元组。列表是可变的，元组和字符串是不可变的。

成员资格。in操作符可以检查一个值是否存在于序列（或者其他的容器中）。对字符串使用in操作符是一个特例--他可以查找子字符串。

方法。一些内建的类型（例如列表和字符串，元组则不再其中）具有很多有用的方法。

新函数

cmp（x,y）比较两个值

len（seq）返回序列的长度

list（seq）把序列转换成列表

max（args） 返回序列或者参数集合中的最大值

min（args） 返回序列或者参数集合中的最小值

reversed（seq） 对序列进行反向迭代

sorted（seq）返回已排序的包含seq所有元素的列表

tuple（seq） 把序列转换成元组