第三章 Python容器：列表、元组、字典与集合

3.1 列表和元组

除字符串以外，Python还有另外两种序列结构：元组和列表。他们都可以包换0个或多个元素，元组并不要求所含元素的种类相同，每个元素可以是各种类型的Python对象。
元组是不可变的。
列表是可变的。

3.2 列表

列表非常适合利用顺序和位置定位某一元素，尤其是当元素的顺序或内容经常发生改变时。在列表中，具有相同值的元素可以重复出现多次。

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

todos_list = ['get gloves', 'get mask', 'get cat vitamins', 'call ambulance']

也可以使用list()：

another_list  = list()
print(another_list)

输出：
[]
如果你只想要记录一些互相不相同的值，集合（set）会是一个更好的选择。

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

Python中的list()可以将其他的数据类型转换成列表类型。

print(list('cat'))

输出：
[‘c’, ‘a’, ‘t’]

将一个元组转换成列表：

a_tuple = ('ready','fire','aim')
print(list(a_tuple))

输出：
[‘ready’, ‘fire’, ‘aim’]

使用split()可以根据分隔符将字符串切割成由若干子串组成的列表（如果待分割的字符串里包含连续的分隔符，返回的列表会出现空元素）：

birthday = '30/7/1996'
print(birthday.split('/'))

输出：
[‘30’, ‘7’, ‘1996’]

3.2.3 使用[offset]获取元素

和字符串一样可以通过偏移量提取对应位置的元素，同样负偏移量代表从尾部开始计数。

3.2.4 包含列表的列表

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

small_birds = ['humiingbird','finch']
extinct_birds = ['dodo','passenger pieon','Norwgian Blue']
carol_birds = [3,'Fernch hens',2,'turtledoves']
all_birds = [small_birds,extinct_birds,carol_birds]
print(all_birds)

输出：
[[‘humiingbird’, ‘finch’], [‘dodo’, ‘passenger pieon’, ‘Norwgian Blue’], [3, ‘Fernch hens’, 2, ‘turtledoves’]]

访问第一个元素：

print(all_birds[0])

输出：
[‘humiingbird’, ‘finch’]

访问第二个元素的第一个元素：

print(all_birds[1][0])

输出：
dodo

3.2.5 使用[offset]修改元素

可以通过赋值对其进行修改，列表的偏移量必须合法：

extinct_birds = ['dodo','passenger pieon','Norwgian Blue']
extinct_birds[2]='unknown'
print(extinct_birds)

输出：
[‘dodo’, ‘passenger pieon’, ‘unknown’]

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

使用切片提取列表的一个子序列：

extinct_birds = ['dodo','passenger pieon','Norwgian Blue']
print(extinct_birds[0:2])

输出：
[‘dodo’, ‘passenger pieon’]

与字符串相同，列表也可以设置步长：

print(extinct_birds[::2])

输出：
[‘dodo’, ‘Norwgian Blue’]

实现列表逆序：

print(extinct_birds[::-1])

输出：
[‘Norwgian Blue’, ‘passenger pieon’, ‘dodo’]

3.2.7 使用append()添加元素至尾部

extinct_birds = ['dodo','passenger pieon','Norwgian Blue']
extinct_birds.append('unknown')
print(extinct_birds)

输出：
[‘dodo’, ‘passenger pieon’, ‘Norwgian Blue’, ‘unknown’]

3.2.8 使用extend()或+=合并列表

使用extend()可以将一个列表合并到另外一个列表中：

marxes = ['Groucho','Chico','Harpo','Zeppo']
others = ['Gummo','Karl']
marxes.extend(others)
print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’, ‘Zeppo’, ‘Gummo’, ‘Karl’]

也可使用+=：

marxes = ['Groucho','Chico','Harpo','Zeppo']
others = ['Gummo','Karl']
marxes += others
print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’, ‘Zeppo’, ‘Gummo’, ‘Karl’]

如果错误的使用了append()：

marxes = ['Groucho','Chico','Harpo','Zeppo']
others = ['Gummo','Karl']
marxes.append(others)
print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’, ‘Zeppo’, [‘Gummo’, ‘Karl’]]

3.2.9 使用insert()在指定位置插入元素

使用insert()可以在指定为止插入元素，指定偏移量为0在列表头插入，如果指定的偏移量超过最长则会插入到最后：

marxes = ['Groucho','Chico','Harpo','Zeppo']
marxes.insert(3,'Gummo')
print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’, ‘Gummo’, ‘Zeppo’]

3.2.10 使用del删除指定元素

删除一个元素（删除元素会被后面的元素填补，且长度-1）：

marxes = ['Groucho','Chico','Harpo','Zeppo']
del marxes[-1]
print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’]
注意：del是Python语句，而不是列表方法。

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

如果不确定和关心元素在列表中的位置，可以使用remove()根据指定的值删除元素：

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

输出：
[‘Groucho’, ‘Harpo’, ‘Zeppo’]

3.2.12 使用pop()获取并删除指定位置的元素

使用pop()同样可获取列表中指定位置的元素，但在获取后，该元素会自动删除。如果为其指定偏移量，会返回偏移量对应位置的元素；如果不指定，则默认是-1。
因此pop(0)会返回列表的头元素，pop()或者pop(-1)会返回列表的尾元素。

marxes = ['Groucho','Chico','Harpo','Zeppo']
print(marxes.pop())
print(marxes)

输出：
Zeppo
[‘Groucho’, ‘Chico’, ‘Harpo’]

marxes = ['Groucho','Chico','Harpo','Zeppo']
print(marxes.pop(1))
print(marxes)

输出：
Chico
[‘Groucho’, ‘Harpo’, ‘Zeppo’]

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

找到某个值元素对应列表的位置，使用index()：

marxes = ['Groucho','Chico','Harpo','Zeppo']
print(marxes.index('Chico'))

输出：
1

3.2.14使用in判断值是否存在

判断一个值在列表中是否存在使用in（只要出现一次就会返回True）：

marxes = ['Groucho','Chico','Harpo','Zeppo']
print('Chico' in marxes)

输出：
True

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

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

marxes = ['Groucho','Chico','Harpo','Zeppo']
print(marxes.count('Chico'))

输出：
1

3.2.16使用join()转换为字符串

join()实际是一个字符串方法，不是列表方法。join()函数的参数是字符串或者其他可以迭代的包含字符串的序列，它的输出是一个字符串。

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

输出：
Groucho,Chico,Harpo,Zeppo

3.2.17使用sort()重新排列元素

对列表中的元素按值排列：

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

如果列表中都是数字，会默认被排列成从小到大；如果是字母，则是字母表顺序排列（参数默认是升序的，可以添加参数reverse = True改变成降序）：

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

输出：
[‘Chico’, ‘Groucho’, ‘Harpo’, ‘Zeppo’]
sorted_marxes是一个副本，不会改变原来的值：

print(marxes)

输出：
[‘Groucho’, ‘Chico’, ‘Harpo’, ‘Zeppo’]

但对marxes列表采用sort()函数时，会改变：

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

输出：
[‘Chico’, ‘Groucho’, ‘Harpo’, ‘Zeppo’]

3.2.18使用len()获取长度

len()获取列表长度。

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

将一个列表的值复制到另外一个表中：

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

a = [1,2,3]
b = a.copy()
c = list(a)
d = a[:]
a[0]='integer lists are boring'
print(a)
print(b)
print(c)

输出：
[‘integer lists are boring’, 2, 3]
[1, 2, 3]
[1, 2, 3]

3.3元组

元组是不可变的。

3.3.1使用()创建元组

用()创建元组：

empty_tuple = ()
print(empty_tuple)

输出：
()

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

one_marx = 'Groucho'，
print(one_marx)

输出：
(‘Groucho’,)
备注：这里如果没有,就输出Groucho

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

one_marx = ('Grouch','Chico','Zeppo')
print(one_marx)

输出：
(‘Grouch’, ‘Chico’, ‘Zeppo’)

可以把元组赋值给多个变量（也称作元素解包）：

one_marx = ('Grouch','Chico','Zeppo')
a,b,c = one_marx
print(a)
print(b)
print(c)

输出：
Grouch
Chico
Zeppo

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

one_marx = ['Grouch','Chico','Zeppo']
print(tuple(one_marx))

输出：
(‘Grouch’, ‘Chico’, ‘Zeppo’)

3.3.2元组与列表

使用元组的原因：

元组占用的空间小
不会意外修改元组的值
元组作为字典的键
命名元组
函数的参数以元组形式传递

3.4字典

字典（dictionary）其中的元素顺序无关紧要，每个元素拥有与之对应的互不相同的键（key），需要通过键来访问元素。键通常是字符串，也可以是其他不更变的类型。

3.4.1使用{}创建字典

用大括号{}将一系列以逗号隔开的键值对（key：value）包裹起来就行字典的创建。（创建空字典略。）
Python允许在列表、元组或字典的最后一个元素后面添加逗号，这并不会产生任何问题。

3.4.2使用dict()转换为字典

使用dict()将包含双值子序列的序列转换为字典（可以对任何包含双值子序列的序列使用，略）：

lol = [['a','b'],['c','d'],['e','f']]
print(dict(lol))

输出：
{‘a’: ‘b’, ‘c’: ‘d’, ‘e’: ‘f’}
注意：字典的顺序无关紧要。

3.4.3使用[key]添加或修改元素

向字典中添加元素很简单，只需要指定该元素的键并赋予值就可。

已有元素，覆盖。
元素不存在，添加。

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael',
}
print(pythons)

输出：
{‘Chapman’: ‘Graham’, ‘Clesse’: ‘John’, ‘Idle’: ‘Eric’, ‘Jones’: ‘Terry’, ‘Palin’: ‘Michael’}
修改字典的值：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael',
}pythons['Gilliam']='Terry'
print(pythons)

输出：
{‘Chapman’: ‘Graham’, ‘Clesse’: ‘John’, ‘Idle’: ‘Eric’, ‘Jones’: ‘Terry’, ‘Palin’: ‘Michael’, ‘Gilliam’: ‘Terry’}
注意：字典的键必须保证互不相同

3.4.4使用update()更新字典

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

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael',
}others= {'Marx':'Grouch','Howard':'Meo',
}
pythons.update(others)
print(pythons)

输出：
{‘Chapman’: ‘Graham’, ‘Clesse’: ‘John’, ‘Idle’: ‘Eric’, ‘Jones’: ‘Terry’, ‘Palin’: ‘Michael’, ‘Marx’: ‘Grouch’, ‘Howard’: ‘Meo’}

如果添加的字典与以前的字典有同样的键会覆盖。

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

使用del删除：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}del pythons['Marx']
print(pythons)

输出：
{‘Chapman’: ‘Graham’, ‘Clesse’: ‘John’, ‘Idle’: ‘Eric’, ‘Jones’: ‘Terry’, ‘Palin’: ‘Michael’, ‘Howard’: ‘Meo’}

3.4.6使用clear()删除所有元素

使用clear()将字典中所有元素删除：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}pythons.clear()
print(pythons)

输出：
{}

3.4.7使用in判断元素是否存在

使用in进行判断元素存在与否：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}print('Marx' in pythons)

输出：
True

3.4.8使用[key]获取元素

使用[key]来获取元素的值：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}print(pythons['Howard'])

输出：
Meo

还有一种方法是使用字典函数get()：

print(pythons.get('Howard'))

输出：
Meo

3.4.9使用keys()获取所有键

使用keys()函数可以活的所有键：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}print(pythons.keys())

输出：
dict_keys([‘Chapman’, ‘Clesse’, ‘Idle’, ‘Jones’, ‘Palin’, ‘Marx’, ‘Howard’])
注意：你只能通过list()将迭代换成一个列表。

3.4.10使用values()获取所有值

使用values()获取所有值：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}print(pythons.values())

输出：
dict_values([‘Graham’, ‘John’, ‘Eric’, ‘Terry’, ‘Michael’, ‘Grouch’, ‘Meo’])

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

使用items()获取键值对：

pythons = {'Chapman':'Graham','Clesse':'John','Idle':'Eric','Jones':'Terry','Palin':'Michael','Marx': 'Grouch','Howard': 'Meo',
}print(pythons.items())
print(list(pythons.items()))

输出：
dict_items([(‘Chapman’, ‘Graham’), (‘Clesse’, ‘John’), (‘Idle’, ‘Eric’), (‘Jones’, ‘Terry’), (‘Palin’, ‘Michael’), (‘Marx’, ‘Grouch’), (‘Howard’, ‘Meo’)])
[(‘Chapman’, ‘Graham’), (‘Clesse’, ‘John’), (‘Idle’, ‘Eric’), (‘Jones’, ‘Terry’), (‘Palin’, ‘Michael’), (‘Marx’, ‘Grouch’), (‘Howard’, ‘Meo’)]

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

与列表一样，对字典内容的修改会反应在所有与之相联的变量名上。想要避免这种情况，可以使用copy()将字典复制到另外个字典中。（代码略）

3.5集合

3.5.1 使用set()创建集合

使用set()创建集合（集合是无序的）：

empty_set = set()
even= {1,2,3,4,5,6}
print(empty_set)
print(even)

输出：
set()
{1, 2, 3, 4, 5, 6}

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

代码：

print(set('letter'))

输出：
{‘t’, ‘r’, ‘e’, ‘l’}

在字典作为传入参数进入set()时，只有键会被使用。

3.5.3 使用in测试值是否存在

使用in测试是否存在于集合中：

even= {1,2,3,4,5,6}
print(9 in even)

输出：
False

3.5.4 合并及运算符

多个集合之间的并列的结果：p56代码重要

&称为交集运算符，它包含所有同时出现在你比较的两个清单中的元素。
也可以使用集合函数intersection()获取集合的交集。

a = {1,2}
b = {2,3}
print(a&b)
print(a.intersection(b))

输出：
{2}
{2}

使用|或者union()来获取集合的并集：

print(a|b)
print(a.union(b))

输出：
{1, 2, 3}
{1, 2, 3}

使用-或者difference()可以获得两个集合的差集（出现在第一个集合但不出现在第二个集合）：

print(a-b)
print(a.difference(b))

输出：
{1}
{1}

使用^或者symmetric_difference()获取两个集合的异或集（仅在两个集合出现一次）：

print(a^b)
print(a.symmetric_difference(b))

输出：
{1, 3}
{1, 3}

使用<=或者issubset()判断是否是子集：

print(a<=b)
print(a.issubset(b))

输出：
False
False

3.6比较几种数据结构

对列表和元组来说，方括号里的内容是整型偏移量；而对于字典来说，方括号的内容是键。