Python的容器：列表、元组、字典与集合

列表

列表是非常容易更改的，可以直接对原始列表进行修改：添加新元素、删除或覆盖已有元素。列表中的元素可以出现多次。

使用[]或list()创建列表

列表由0或多个元素组成，元素之间用逗号分开，整个列表被[]包裹。

>>> empty_list = []  # 创建空列表
>>> big_birds = ['emu','ostrich','cassowary'] #创建一个包含3个元素的列表
>>> another_empty_list = list()   # 创建空列表

使用[list()将其他数据类型转换为列表

>>> list('cat')
['c', 'a', 't']

也可以使用split()分割字符串生成列表

>>> birthday = '1/6/1952'
>>> birthday.split('/')
['1', '6', '1952']

如果字符串中有连续的分隔符，则会返回空串元素

>>> splitme = 'a/b//c/d///e'
>>> splitme.split('/')
['a', 'b', '', 'c', 'd', '', '', 'e']

将分隔符改为’//’后的结果如下

>>> splitme.split('//')
['a/b', 'c/d', '/e']

包含列表的列表

在列表中可以包含各种类型的元素，也包括其他列表

>>> all_birds = [['hummingbird','finch'],3,5,'French hens',[1,2,3]]
>>> print(all_birds)
[['hummingbird', 'finch'], 3, 5, 'French hens', [1, 2, 3]]

使用[offset]修改元素

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes[2] = 'Wanda'
>>> marxes
['Groucho', 'Chico', 'Wanda']

删除列表中的元素

删除列表中的元素有很多种方法
使用del删除指定位置的元素

>>> marxes = ['Groucho','Chico','Harpo']
>>> del marxes[1]
>>> marxes
['Groucho', 'Harpo']

使用remove()删除具有指定值的元素

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.remove('Chico')
>>> marxes
['Groucho', 'Harpo']

使用pop()获取并删除指定位置的元素，pop()中需要一个偏移量参数，如果省略，则会返回队尾元素

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.pop(1)
'Chico'
>>> big_birds = ['emu','ostrich','cassowary']
>>> big_birds.pop()
'cassowary'

添加元素至列表

使用append()添加元素

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.append('Zeppo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']

需要注意的是append()会将要添加的元素作为一个整体添加到列表的尾部，就如同下面这样

>>> marxes = ['Groucho','Chico','Harpo']
>>> big_birds = ['emu','ostrich','cassowary']
>>> marxes.append(big_birds)
>>> marxes
['Groucho', 'Chico', 'Harpo', ['emu', 'ostrich', 'cassowary']]

使用extend()或+=合并列表
这两个操作都是将两个列表合并成一个列表，并不会出现append()那种情况

>>> marxes = ['Groucho','Chico','Harpo']
>>> big_birds = ['emu','ostrich','cassowary']
>>> marxes.extend(big_birds)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'emu', 'ostrich', 'cassowary']

>>> marxes = ['Groucho','Chico','Harpo']
>>> others = ['Gummo','Karl']
>>> marxes += others
>>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Karl']

使用insert()在指定位置插入元素
与append()类似，append()只能将元素插入到列表尾部，而insert()可以将元素插入到任意位置

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.insert(2,'Gummo')
>>> marxes
['Groucho', 'Chico', 'Gummo', 'Harpo']

查找列表中的元素

使用index()查询具有特定值的元素位置

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.index('Chico')
1

使用in判断值是否存在

>>> 'Chico' in marxes
True
>>> 'Bob' in marxes
False

使用count()记录特定值出现的次数

>>> marxes.count('Chico')
1
>>> marxes.count('Bob')
0

指定范围并使用切片提取元素

这个与字符串的切片使用方法一样，只不过列表的切片仍然是一个列表，也可以使用切片实现列表的逆序

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes[0:2]
['Groucho', 'Chico']
>>> marxes[::-1]
['Harpo', 'Chico', 'Groucho']
>>> 

使用join()转换为字符串

join()是一个字符串方法，并不是列表方法。join()函数的参数是字符串或者是其他的包含字符串的序列。这里有两种方式使用join()

>>> marxes = ['Groucho','Chico','Harpo']
>>> ','.join(marxes)
'Groucho,Chico,Harpo'

>>> separator = ','
>>> separator.join(marxes)
'Groucho,Chico,Harpo'

使用sort()重新排列元素

列表方法sort()会对原列表进行排序，改变原列表的内容

>>> marxes = ['Groucho','Chico','Harpo']
>>> marxes.sort()
>>> marxes
['Chico', 'Groucho', 'Harpo']

通用函数sorted()则会返回排好序的列表副本，原列表内容不变

>>> sorted_marxes = sorted(marxes)
>>> sorted_marxes
['Chico', 'Groucho', 'Harpo']
>>> marxes
['Groucho', 'Chico', 'Harpo'] 

如果列表中的元素都是数字，它们会默认地被排列成从小到大的升序。如果元素都是字符串，则会按照字母表顺序排列。
默认的排序是升序的，通过添加参数reverse = True 可以改变为降序排序

>>> marxes.sort(reverse = True)
>>> marxes
['Harpo', 'Groucho', 'Chico']

>>> sorted_marxes = sorted(marxes,reverse = True)
>>> sorted_marxes
['Harpo', 'Groucho', 'Chico']

使用len()获取长度

>>> len(marxes)
3

使用=赋值，使用copy()复制

如果将一个列表赋值给多个变量，改变其中任何一处都会造成其他变量对应的值的改变。

>>> a = [1,2,3]
>>> b=a
>>> c=b
>>> a[0]='surprise'
>>> b
['surprise', 2, 3]
>>> c
['surprise', 2, 3]

同样的，修改b的值，a和c的值也会改变
但是通过下面几种方法复制的话就不会出现这种情况

列表copy()函数
list()转换函数
列表分片[:]

测试结果如下，a为初始列表，b用copy函数创建，c用list()函数创建，d用列表分片创建

>>> a = [1,2,3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:]
>>> a[0] = 'surprise'
>>> a
['surprise', 2, 3]
>>> b
[1, 2, 3]
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]

 

元组

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

创建元组

可以使用()创建一个空元组

>>> empty_tuple = ()
>>> empty_tuple
()

当创建的元组只包含一个元素时，后面的逗号不能省略，因为()也可以表示为数学公式中的小括号，从而产生错误

>>> other_tuple = (123,)
>>> other_tuple
(123,)

>>> one_tuple = (123)
>>> one_tuple
123

使用tuple()将其他类型的数据转换为元组

>>> mar = ['Croucho','Chico','Harpo']
>>> tuple(mar)
('Croucho', 'Chico', 'Harpo')

元组的操作方法

虽然元组无法改变，但可以将两个元组拼接起来创建一个新的元组

>>> tuple1 = (1,2,3)
>>> tuple2 = (4,5,6)
>>> tuple3 = tuple1 + tuple2
>>> tuple3
(1, 2, 3, 4, 5, 6)

在元组中，可以同时将元组赋值给多个变量

>>> mar = ('Croucho','Chico','Harpo')
>>> a,b,c = mar
>>> a
'Croucho'
>>> b
'Chico'
>>> c
'Harpo'

也可以用这个方法来对多个变量的值进行交换

>>> password = 'swordfish'
>>> icecream = 'tutifrutti'
>>> password,icecream = icecream,password
>>> password
'tutifrutti'
>>> icecream
'swordfish'

 

字典

字典中的每个元素拥有与之对应的互不相同的键，需要通过键来访问元素。键通常是字符串，也可以是其他任意的不可变类型。字典是可变的，可以增加、删除或修改其中的键值对。键与键之间不可重复

创建字典

使用{}创建字典，用{}将一系列以逗号隔开的键值对(key:value)包裹起来即可进行字典的创建。

>>> empty_dict = {}
>>> empty_dict
{}
>>> other_dict = {'a':'b','c':'d','e':'f'}
>>> other_dict
{'e': 'f', 'c': 'd', 'a': 'b'}

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

>>> lol = [['a','b'],['c','d'],['e','f']]
>>> dict(lol)
{'e': 'f', 'c': 'd', 'a': 'b'}
>>> top = ('ab','cd','ef')
>>> dict(top)
{'e': 'f', 'c': 'd', 'a': 'b'}

修改或添加字典中的元素

使用[key]修改或添加元素，如果该元素的键已存在于字典中，那么该键对应的旧值会被新值取代。如果该元素的键未在字典中出现，则会被加入字典

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> pythons
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John'}
>>> pythons['Gilliam'] = 'Gerry'
>>> pythons
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John', 'Gilliam': 'Gerry'}
>>> pythons['Gilliam'] = 'Terry'
>>> pythons
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John', 'Gilliam': 'Terry'}

使用update()合并字典，使用update()可以将一个字典的键值对复制到另一个字典中去

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> others = {'Marx':'Groucho','Howard':'Moe'}
>>> pythons.update(others)
>>> pythons
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John', 'Howard': 'Moe', 'Marx': 'Groucho'}

删除字典中的元素

使用del删除具有指定键的元素

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> del pythons['Chapman']
>>> pythons
{'Idle': 'Eric', 'Cleese': 'John'}

使用clear()删除所有元素

>>> pythons.clear()
>>> pythons
{}

获取字典中的元素

使用in判断某一个键是否存在于字典中

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> 'Jones' in pythons
False
>>> 'Chapman' in pythons
True

使用[key]获取元素

>>> pythons['Chapman']
'Graham'

使用keys()获取所有键

>>> pythons.keys()
dict_keys(['Idle', 'Chapman', 'Cleese'])

使用values()获取所有值

>>> pythons.values()
dict_values(['Eric', 'Graham', 'John'])

使用items()获取所有键值对

>>> pythons.items()
dict_items([('Idle', 'Eric'), ('Chapman', 'Graham'), ('Cleese', 'John')])

需要注意的是，你需要自己手动使用list()函数，将keys()、values()和items()的返回值转换为普通的Python列表

>>> list(pythons.keys())
['Idle', 'Chapman', 'Cleese']
>>> list(pythons.values())
['Eric', 'Graham', 'John']
>>> list(pythons.items())
[('Idle', 'Eric'), ('Chapman', 'Graham'), ('Cleese', 'John')]

使用=赋值，使用copy()复制

与列表一样，使用复制的话，对字典内容进行的修改会反映到所有与之相关联的变量名上

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> others = pythons
>>> others
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John'}
>>> pythons['Idle'] = 'Bob'
>>> pythons
{'Idle': 'Bob', 'Chapman': 'Graham', 'Cleese': 'John'}
>>> others
{'Idle': 'Bob', 'Chapman': 'Graham', 'Cleese': 'John'}

使用copy()就可以避免这种情况

>>> pythons = {'Chapman':'Graham','Cleese':'John','Idle':'Eric'}
>>> others = pythons.copy()
>>> others
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John'}
>>> pythons['Idle'] = 'Bob'
>>> pythons
{'Idle': 'Bob', 'Chapman': 'Graham', 'Cleese': 'John'}
>>> others
{'Idle': 'Eric', 'Chapman': 'Graham', 'Cleese': 'John'}

setdefault()与defaultdict()

读取字典中不存在的键的值会抛出异常。使用字典函数get()会返回一个默认值避免异常发生，setdefault()与get()类似，但当键不存在时，它会在字典中添加一项

>>> peridic_table = {'Hydrogen':1,'Helium':2}
>>> carbon = peridic_table.setdefault('Carbon',3)
>>> carbon
3
>>> peridic_table
{'Hydrogen': 1, 'Helium': 2, 'Carbon': 3}

如果查询的是字典中已经存在的键，并不会改变原来的值，仍返回初始值

>>> helium = peridic_table.setdefault('Helium',123)
>>> helium
2
>>> peridic_table
{'Hydrogen': 1, 'Helium': 2, 'Carbon': 3}

defaultdict()在创建字典时，会对每个新的键指定默认值，它的参数是一个函数

>>> from collections import defaultdict
>>> peridic_table = defaultdict(int) # 使用int,会按照int()调用，返回整数0
>>> peridic_table['Hydrogen'] = 1
>>> peridic_table['Lead']   # 不存在的键都会返回0
0
>>> peridic_table
defaultdict(<class 'int'>, {'Hydrogen': 1, 'Lead': 0})

当然，参数也可以使用自己定义的函数

>>> def no_idea():
    return 'T'

>>> bestiary = defaultdict(no_idea)
>>> bestiary['A'] = 'Snowman'
>>> bestiary['B']
'T'

>>> bestiary = defaultdict(lambda:'T')// 使用lambda定义默认函数
>>> bestiary['D']
'T'

函数的返回值

    int()  返回0
    list()  返回空列表[]
    dict()  返回空字典{}

Counter()函数

Counter()是一个计数器函数

>>> from collections import Counter
>>> breakfast = ['spam','spam','spam','egg']
>>> breakfast_counter = Counter(breakfast)
>>> breakfast_counter
Counter({'spam': 3, 'egg': 1})

使用most_common()可以降序返回所有元素，或者给定一个数字，会返回该数字前的元素

>>> breakfast_counter.most_common()
[('spam', 3), ('egg', 1)]
>>> breakfast_counter.most_common(1)
[('spam', 3)]

使用运算符处理多个计数器

>>> breakfast_counter + lunch_counter # 使用'+'组合计数器，相同键的值会相加
Counter({'spam': 3, 'egg': 3, 'bacon': 1}) 

>>> breakfast_counter - lunch_counter # 使用'-'求差，相同键的值相减，但并不会出现负值和0
Counter({'spam': 3})
>>> lunch_counter - breakfast_counter
Counter({'egg': 1, 'bacon': 1})

>>> breakfast_counter & lunch_counter  #使用'&'得到共有的项，相同键的值会返回较小的那一个
Counter({'egg': 1})

>>> breakfast_counter | lunch_counter #使用'|'合并计数器，相同键的值会返回较大的那一个
Counter({'spam': 3, 'egg': 2, 'bacon': 1})

集合

集合就如同去掉值的字典一样，键与键之间不可重复。集合中的元素不可重复

创建集合

使用set()创建集合，或使用大括号将一系列以逗号隔开的值包裹起来创建集合

>>> empty_set = set()
>>> empty_set
set()

>>> other_set = {1,2,3,4,5}
>>> other_set
{1, 2, 3, 4, 5}

使用set()将其他类型转换为集合

>>> set('letters')
{'l', 's', 't', 'r', 'e'}
>>> set(['Dasher','Dasher','Dancer','Dancer'])
{'Dancer', 'Dasher'}

这个例子就可以体现出，集合中的元素不可重复的特点

使用in测试值是否存在

这是集合最常用的功能

>>> others = {1,2,3,4,5,6}
>>> 6 in others
True
>>> 7 in others
False

合并及运算符

交集运算符 &，返回两个集合中都存在的元素。也可以使用intersection()获取两个集合的交集

>>> a = {1,2,3,4,5}
>>> b = {2,3,6,7,8}
>>> a&b
{2, 3}
>>> a.intersection(b)
{2, 3}

并集运算符 |，返回两个集合中出现的元素。也可以使用union()函数获取两个集合的并集

>>> a|b
{1, 2, 3, 4, 5, 6, 7, 8}
>>> a.union(b)
{1, 2, 3, 4, 5, 6, 7, 8}

差集运算符 -，返回两个集合的差集（出现在第一个集合，但不出现第二个集合中的元素）。也可以使用difference()函数获取两个集合的差集

>>> a-b
{1, 4, 5}
>>> a.difference(b)
{1, 4, 5}
>>> b-a
{8, 6, 7}
>>> b.difference(a)
{8, 6, 7}

异或运算符 ^，返回两个集合的异或集（仅在两个集合中出现一次）。也可以使用symmetric_difference()函数获取两个集合的异或集

>>> a^b
{1, 4, 5, 6, 7, 8}
>>> a.symmetric_difference(b)
{1, 4, 5, 6, 7, 8}

子集与超集

子集与超集正好相反，第一个集合是第二个集合的子集，那么第二个集合就是第一个集合的超集，当然，还有真子集与真超集，这个与高中所学的集合是完全一样的
使用<=或者issubset()可以判断一个集合是否是另一个集合的子集

>>> b = {1,2,3,4,5}
>>> a = {2,3,4}
>>> a <= b
True
>>> a <= a
True
>>> b.issubset(a)
False

使用>=或者issuperset()可以判断一个集合是否是另一个集合的超集

>>> a >= b
False
>>> a >= a
True
>>> a.issuperset(b)
False

判断真集只需将=号去掉即可。