python学习总结——列表

列表

1.列表基本概念

列表是一种有顺序的序列，与c语言的数组写法有些相似，也可以通过索引对其元素进行访问。不同的是，列表的元素可以不是同一种类型。一个列表中可以包含任意类型的python对象，如数字、字符串、列表等等。如：

>>> myList =  [1,2.3,"list",['a','b','c']]

>>> myList

[1, 2.3, 'list', ['a', 'b', 'c']]

2.列表创建

创建空列表 li = []

创建长度为n的列表 li = [None]*n

创建含初始元素的列表 li = [1,2,3]

3.列表的操作：

3.1 获取一个列表list()

我们可以直接创建一个列表，也可以通过内建函数list()获取原有对象的一个列表。

用法:list(iterable)。该函数返回一个可迭代对象（如字符串、列表等）的列表。如：

>>> list('hello,world')

['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd']

3.2 获取列表元素

A.索引法：获取单个元素

列表中第一个元素索引为0，然后依次递增1。需要说明的是，python还支持负数索引。如，列表最后一个元素索引为-1，倒数第二个是-2...。Python中除了第一个元素只有一个索引0外，其他元素都有正负两个索引供我们使用。如：

>>> myList = ['a','b','c','d']

>>> myList[1]

'b'

>>> myList[-1]

'd'

>>> myList[-2]

'c'

需要注意的是，当访问的索引越界时，会引发IndexError.

B.分片法：获取一块元素

我们可以通过list_name[index_begin : index_end : step]这样的格式获取列表的一块元素的副本。

说明：

1.分片获得从起始索引到结束索引之间的元素，不包括结束索引

2.默认步长为1，可以显示指定。步长可以为正，也可以为负。正的步长表示从前向后开始复制，负的步长表示从后向前复制。要注意的是，索引的起始和结束值与步长方向要一致。

3.索引可以缺省，缺省时表示从字符串开头（步长为正），或者字符串末尾（步长为负）进行复制。起始和结束索引都缺省时表示复制整个字符串

如：

>>> myList = [1,2,3,4,5,6,7]

#默认步长正的索引

>>> myList[1:4]

[2, 3, 4]

#默认步长负索引

>>> myList[-4:-1]

[4, 5, 6]

#显示指定步长

>>> myList[1:6:2]

[2, 4, 6]

>>> myList[-5:-1:2]

[3, 5]

>>> myList[-1:-6:-2]

[7, 5, 3]

#索引缺省

>>> myList[:]

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

>>> myList[::2]

[1, 3, 5, 7]

3.3 给列表添加元素

A. 连接符+：两个列表相加

用法：List1+List2，+运算符可以将第二个列表追加到第一个列表后面。如

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

>>> charList = ['h','e','l','l','o']

>>> myList+charList

[1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']

B.append():在列表末尾追加一个元素

用法：List.append(element),将对象element作为一个元素追加到列表List末尾。

如：

>>> myList = ['One','world',',']

>>> myList.append(['one','dream'])

>>> myList.append('!')

>>> myList

['One', 'world', ',', ['one', 'dream'], '!']

可以看到，append()可以为列表追加任意类型的对象，该对象作为一个整体成为列表的元素。

C.extend():在列表末尾追加多个元素

extend()与append()不同的是若添加的对象是一个列表，会将其中的每一个元素分别追加大原列表末尾。如：

>>> myList = ['a','b','c']

>>> myList.extend('d')

>>> myList

['a', 'b', 'c', 'd']

>>> myList.extend(['e','f','g'])

>>> myList

['a', 'b', 'c', 'd', 'e', 'f', 'g']

D. insert():将对象插入到列表中

用法：list.insert(index,obj)。将对象obj插入到列表指定的位置。如

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

>>> lst.insert(1,'a')

>>> lst

[1, 'a', 2, 3, 4]

>>> lst.insert(6,'d')

>>> lst

[1, 'a', 2, 3, 4, 'd']

>>> lst.insert(-1,'f')

>>> lst

[1, 'a', 2, 3, 4, 'f', 'd']

3.4  删除列表元素

A.remove()

用法：list.remove(obj),删除列表中obj的第一个匹配项。若obj不存在则引发异常。

如：

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

>>> lst.remove('to')

>>> lst

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

>>> lst.remove('no')

Traceback (most recent call last):

  File "", line 1, in 

    lst.remove('no')

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

B.pop()

　　用法：list.pop(index)。删除列表索引为index的值，并将该值返回。Index默认值为-1，即删除列表的最后一个元素。如：

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

>>> lst.pop()

'be'

>>> lst

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

>>> lst.pop(2)

'or'

>>> lst

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

3.5 获取列表长度len()

通过内建函数len()可以获取对象的大小。如：

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

>>> len(lst)

6

3.6 获取列表中的最大值/最小值max()/min()

通过内建函数max(),min()获取对象的最大最小值，如

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

>>> max(lst)

'to'

>>> min(lst)

'be'

3.7 获取列表中元素的索引值index()

用法：list.index(obj)。返回列表中第一个匹配的元素的索引值。若该对象不在列表中，引发异常。

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

>>> lst.index('be')

1

>>> lst.index('hi')

Traceback (most recent call last):

  File "", line 1, in 

    lst.index('hi')

ValueError: 'hi' is not in list

说明：

与该方法类似的是in运算符，用于判断某元素是否在列表中，返回值是布尔型。如：

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

>>> 'or' in lst

True

>>> 'bee' in lst

False

3.8 获取列表中某元素出现的次数count()

List.count(obj)，返回对象obj在列表中出现的次数。如：

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

>>> lst.count('to')

2

>>> lst.count('1')

0 

3.9 获取列表逆序列表reverse()

reverse()方法将列表中的元素逆序存放。如：

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

>>> lst.reverse()

>>> lst

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

3.10 列表排序

A:sort()

用法：list.sort().将列表元素按默认排序规则升序排列。原列表被改变。如：

>>> lst = [9,2,3,28,0,-1]

>>> lst.sort()

>>> lst

[-1, 0, 2, 3, 9, 28]

说明：

函数原型list.sort(cmp=None, key=None, reverse=False)。

1.sort()有三个参数cmp,key,reverse,默认值分别是None，None，False。 2.cmp：指定元素比较大小的规则。内建函数cmp()提供了默认的比较规则，我们也可以自定义函数比较规则。

3.Key：为所有元素创建一个键，按该键来对元素进行比较其大小。

4.Reverse:指明列表是按升序还是降序排列。默认值false表示升序。

下面看一个例子：

#自定义比较函数，按对象的长度进行比较

def myCompare(x,y):

    if len(x)return -1

    elif len(x) > len(y):return 1

else:return 0

lst = ['David','Amanda','ashly','jhon','Tom']

cpy = lst[:]

cpy1 = lst[:]

cpy2 = lst[:]

cpy3 = lst[:]

#默认排序

cpy.sort()

#降序排序

cpy1.sort(reverse=True)

#指定key排序:按字符串的小写版排序

cpy2.sort(key=str.lower)

#按自定义比较规则排序

cpy3.sort(cmp=myCompare)

print '原字符串：',lst

print '默认排序：',cpy

print '降序排序：',cpy1

print '指定key排序：',cpy2

print '按自定义比较规则排序',cpy3

程序运行结果：

程序说明：

首先我们自定义了一个比较函数myCompare()，按对象的长度进行比较。

然后我们将元列表lst复制4份，分别进行默认排序，降序排序，指定key排序以及按自定义比较规则进行排序。

最后将排序后的列表输出，结果进行比较。

B:sorted()

用法：sorted(list).sorted()函数是内建函数，可以对可迭代对象进行排序，如列表。它也有可选参数cmp.key.和reverse。如sort()方法不同的是，该函数对列表排序，返回已排好序的列表，而原列表不会被改变。如：

>>> lst = ['david','amanda','ashly','jhon','tom']

>>> newList = sorted(lst)

>>> newList

['amanda', 'ashly', 'david', 'jhon', 'tom']

>>> lst

['david', 'amanda', 'ashly', 'jhon', 'tom']

读者可以对cmp等参数进行测试。

元组

1.基本概念

元组是一个常量列表，它是不可变对象，不能对其进行添加、删除元素等操作。可以像列表一样对其进行索引、分片、连接等操作。

2.创建元组

元组是用圆括号将元素包围起来，元素用逗号隔开。可以把圆括号省略，但是如果只有一个元素，要在后面加个逗号，这样才能成为元组，不然就只是一个对象。如：

#创建元组

>>> tu = (1,'2.3','abc',-12.5,[1,2,3])

>>> tu

(1, '2.3', 'abc', -12.5, [1, 2, 3])

#省略括号

>>> tp = 'how','are','you'

>>> tp

('how', 'are', 'you')

#只有一个元素的元组

>>> tl = 'hello',

>>> tl

('hello',)

#一个对象

>>> tl = 'hello'

>>> tl

'hello'

3.元组的操作　　

元组的操作比较简单，只能对其元素进行访问，而不能进行修改。用法与列表相似。

3.1获取元组：tuple()

同list()函数一样，我们可以通过内建函数tuple()对一个可迭代对象获取元组。如：

>>> tp = tuple('12345')

>>> tp

('1', '2', '3', '4', '5')

3.2 获取元素:

可以通过通过索引、分片获取元组的一个或多个元素。该用法与列表相似，只是分片时返回的是元组。如：

>>> tup = ('this','is','a','tuple')

>>> tup[-2]

'a'

>>> tup[:3]

('this', 'is', 'a')

>>> tup[::2]

('this', 'a')

3.3 检查元素是否存在：in，

>>> 'me' in 'Nothing about me, OK?'

True

3.4连接元组：+，

>>> ('snow','white','is','very','beautiful')+('everyone','love','her')

('snow', 'white', 'is', 'very', 'beautiful', 'everyone', 'love', 'her')

3.5 获取元组长度：len()

>>> len(('do','u','believe','us'))

4

3.6 元组最大/最小值：max()/min()

>>> tu = (1,2.3,'2.3',[2.3],'a')

>>> max(tu)

'a'

>>> min(tu)

1

3.7 获取元素出现的次数：count()

>>> tu = (1,2,3,'a','b,')

>>> tu.count('a')

1

3.8 获取第一个匹配元素的索引：index()

>>> tu = (1,2,3,'a','b,')

>>> tu.index('a')

3