掌握python元组容器_Python学习——Python 容器（列表，元组，字典，集合）

列表：

列表非常适合利用顺序和位置定位某一元素，尤其是当元素的顺序或内容经常发生改变时。与字符串不同，列表是可变的。

你可以直接对原始列表进行修改：添加新元素、删除或覆盖已有元素。在列表中，具有相同值的元素允许出现多次。

使用[] 或者list()创建列表，列表可以由零个或多个元素组成，元素之间用逗号分开，整个列表被方括号所包裹：

>>> empty_list = []

>>> name = ['zhangsan','lisi','wangwu']

>>> other_empty_list = list()

>>> other_empty_list []

list()将其他数据类型转换成列表：

1.将字符串转换成列表

>>> list('dog')

['d','o','g']

2.将元祖转换成列表

>>> tuple = ('dog','cat','mouse')

>>> list(tuple)

['dog','cat','mouse']

使用 split() 可以依据分隔符将字符串切割成由若干子串组成的列表：

>>> birthday = '1/6/1952'

>>> birthday.split('/')

['1', '6', '1952']

如果待分割的字符串中包含连续的分隔符，那么在返回的列表中会出现空串元素：

>>> splitme = 'a/b//c/d///e'

>>> splitme.split('/')

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

列表元素的获取与修改：

>>> list = ['a','b','c','d','e',f']

>>> list[0]

'a'

>>> list[-1]

'f'

>>> list[2:]

['c','d','e','f']

>>> list[::2]

['a','c','e']

>>> list[:-3]

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

>>> list[-3:]

['d','e','f']

>>> list[::-2]

['f','d','b']

#列表中包含列表

>>> list1 = ['one','two','three','four']

>>> list2 = ['cat','dog','mouse']

>>> list3 = ['jack','tom','robet',5]

>>> all_list = [list1,list2,'haha',list3]

>>> all_list

[['one','two','three','four'],['cat','dog','mouse'],'haha',['jack','tom','robet',5]]

>>> all_list[0]

['one','two','three','four']

>>> all_list[0][1]

'two'

#列表值得替换

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

>>> list[1] = 'L'

>>> list

['a','L','b','d']

列表的常用操作：(以下所有操作默认在list列表下进行)

list = ['one','two','three','four']

1.append()添加元素到尾部

>>> list.append('five')

>>> list

['one','two','three','four','five']

2.extend() 或者 += 合并列表

>>> other_list = ['tom','jack']

>>> list.extend(other_list)

>>> list

['one','two','three','four','tom','jack']

或者：

>>> list += other_list

>>> list

['one','two','three','four','tom','jack']

3.insert()在指定位置插入元素

>>> list.insert(3,'hu')

>>> list

['one','two','three','hu','four']

>>> list.insert(10,'hu')

>>> list

['one','two','three','four','hu']

4.del 删除指定位置的元素

>>> del list[1]

>>> list

['one','three','four']

>>> del list[-1]

>>> list

['one','two','three']

5.remove()删除指定值得元素

>>> list.remove('two')

>>> list

['one','three','four']

6.pop()获取并删除指定位置的元素

使用 pop() 同样可以获取列表中指定位置的元素，但在获取完成后，该元素会被自动删除。 如果你为 pop() 指定了偏移量，它会返回偏移量对应位置的元素；

如果不指定，则默认使 用 -1 。 因此， pop(0) 将返回列表的头元素，而 pop() 或 pop(-1) 则会返回列表的尾元素：

>>> list.pop()

'four'

>>> list

['one','two','three']

7.index() 查询具有特定值的元素的位置

>>> list.index('three')

2

8.in 判断值是否存在

>>> 'two' in list

True

9.count()记录特定值出现的次数

>>> list.count('one')

1

>>> list.count('five')

0

10.join()转换为字符串

>>> ','.join(list)

'one,two,three,four'

PS:的调用顺序：join() 是 split() 的逆过程

>>> c='ab,cd,ef'

>>> c.split(',')

['ab','cd','ef']

>>> ','.join(c)

'ab,cd,ef'

11.sort()重新排列元素

列表方法 sort() 会对原列表进行排序，改变原列表内容； 通用函数 sorted() 则会返回排好序的列表副本，原列表内容不变。

如果列表中的元素都是数字，它们会默认地被排列成从小到大的升序。如果元素都是字符串，则会按照字母表顺序排列：

>>> list.sort()

>>> list

['foue','one','three','two']

有些时候甚至多种类型也可——例如整型和浮点型——只要它们之间能够自动地互相转换：

>>> numbers = [2, 1, 4.0, 3]

>>> numbers.sort()

>>> numbers

[1, 2, 3, 4.0]

默认的排序是升序的，通过添加参数 reverse=True 可以改变为降序排列：

>>> numbers = [2, 1, 4.0, 3]

>>> numbers.sort(reverse=True)

>>> numbers

[4.0, 3, 2, 1]

list_copy是一个副本，它的创建并不会改变原始列表的内容：

>>> list_copy = sorted(list)

>>> list_copy

['foue','one','three','two']

12.len() 获取列表长度

>>> list.len()

4

13.copy()函数复制列表

列表叫作 a，然后利用 copy() 函数创建 b ，利用 list() 函数创建 c，并使用列表分片创建 d ：

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

>>> b = a.copy()

>>> c = list(a)

>>> d = a[:]

b、 c 、 d 都是 a 的复制：它们是自身带有值的新对象，与原始的 a 所指向的列表对象 [1, 2, 3] 没有任何关联。 改变 a 不影响 b 、 c 和 d 的复制：

>>> a[0] = 'integer lists are boring'

>>> a

['integer lists are boring', 2, 3]

>>> b

[1, 2, 3]

>>> c

[1, 2, 3]

>>> d

[1, 2, 3]

元组:

与列表类似，元组也是由任意类型元素组成的序列。与列表不同的是，元组是不可变的，这意味着一旦元组被定义， 将无法再进行增加、删除或修改元素等操作。

因此，元组就像是一个常量列表。 使用()创建元组

>>> empty_tuple = ()

>>> empty_tuply

()

创建包含一个或多个元素的元组时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略：

>>> one_marx = 'Groucho',

>>> one_marx ('Groucho',)

PS:如果创建的元组所包含的元素数量超过 1，最后一个元素后面的逗号可以省略.

Python的交互式解释器输出元组时会自动添加一对圆括号。你并不需要这么做——定义元组真正靠的是每个元素的后缀逗号

但如果你习惯添加一对括号也无可厚非。可以用括号将所有元素包裹起来，这会使得程序更加清晰：

可以将元组赋值给多个变量：

>>> tuple = ('one','two','three')

>>> a,b,c = tuple

>>>a

'one'

>>>b

'two'

>>>c

'three'

这个过程叫做元组解包

元组可以对多个变量的值进行交换而不需要利用中间值：

>>> tuple1 = ('first',)

>>> tuple2 = ('last',)

>>> tuple1,tuple2 = tuple2,tuple1

>>> tuple1

'last'

>>> tuple2

'first'

tuple() 函数可以用其他类型的数据来创建元组：

>>> marx_list = ['Groucho', 'Chico', 'Harpo']

>>> tuple(marx_list)

('Groucho', 'Chico', 'Harpo')

字典:

字典 (dictionary)与列表类似，但其中元素的顺序无关紧要，因为它们不是通过像 0 或 1 的偏移量访问的。 取而代之，每个元素拥有与之对应的互不相同的 键 (key)，

需要通过键来访问元素。 键通常是字符串，但它还可以是 Python 中其他任意的不可变类型：布尔型、整型、浮点型、元组、字符串等等。

字典是可变的，因此你可以增加、删除或修改其中的键值对。 用大括号{}将一系列以逗号隔开的 键值对 ( key:value)包裹起来即可进行字典的创建。

最简单的字典是空字典，它不包含任何键值对.

>>> empty_dict = {}

>>> empty_dict {}

字典的常用操作:

dict = {

'one':'1',

'two':'2',

'three':'3',

}

1.dict()转换为字典

可以用 dict() 将包含双值子序列的序列转换成字典。

(你可能会经常遇到这种子序列，例如“Strontium，90，Carbon，14”或者“Vikings，20，Packers，7”，等等。) 每个子序列的第一个元素作为键，第二个元素作为值。

>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]

>>> dict(lol)

{'c': 'd', 'a': 'b', 'e': 'f'}

>>> tos = ( 'ab', 'cd', 'ef' )

>>> dict(tos)

{'c': 'd', 'a': 'b', 'e': 'f'}

2.[key]添加或者修改元素

>>> dict['one'] = 'A'

>>> dict

{'one':'A', 'two':'2','three':'3',}

>>> other = {'four':'4','five':'5'}

>>> dict.update(other)

>>> dict

{'one':'A', 'two':'2','three':'3','four':'4','five':'5'}

PS:如果待添加的字典与待扩充的字典包含同样的键,新归入字典的值会取代原有的值：

>>> first = {'a': 1, 'b': 2}

>>> second = {'b': 'platypus'}

>>> first.update(second)

>>> first

{'b': 'platypus', 'a': 1}

3.del 删除具有指定键的元素

>>> del dict['one']

>>> dict

{'two':'2','three':'3',}

4.clear()删除所有元素

>>> dict.clear()

>>> dict {}

5.in 判断是否存在(只能判断键，不能判断值)

>>> 'one' in dict

True

>>> '1' in dict

False

6.使用[key]获取元素

>>> dict['one']

'1'

PS:使用字典函数get()也可以获取元素

>>> dict.get('one')

'1'

7.keys()获取所有键

>>> dict.keys()

dict_keys(['one','two','three'])

PS:在 Python 2 里， keys() 会返回一个列表，而在 Python 3 中则会返回 dict_keys()，它是键的迭代形式。

只能调用list() 将 dict_keys 转换为列表类型。

>>> list(dict.keys())

['one','two','three']

8.使用values()获取所有值

>>> list(dict.values())

['1','2','3']

9.items()获取所有的键值对 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组

>>> dict.items()

dict_items([('one','1'),('two','2'),('three','3')])

>>> list(dict.items())

[('one','1'),('two','2'),('three','3')]

每个键值对以元组的形式返回。

集合：

集合 就像舍弃了值，仅剩下键的字典一样。键与键之间也不允许重复。与字典的键一样，集合是无序的。

集合的常见操作：

1.使用set()创建集合

>>> empty_set = set()

>>> empty_set set()

2.使用set()将其他类型转换成集合

你可以利用已有列表、字符串、元组或字典的内容来创建集合，其中重复的值会被丢弃。

>>> set('letters') {'l','e','t','r','s'}

注意，上面得到的集合中仅含有一个 'e' 和一个 't'，尽管字符串 'letters' 里各自包含两个。

>>> set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )

{'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}

>>> set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') )

{'Ummagumma', 'Atom Heart Mother', 'Echoes'}

当字典作为参数传入 set() 函数时，只有键会被使用：

>>> set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} )

{'apple', 'cherry', 'orange'}