list(列表)

使用切片不但可以获取数据，也可以对切片位置的数据赋值可迭代类型，来插入或替换数据。
list_object[start:stop:step] = iterable
如果想在将某个位置的元素替换为新的元素，可以像下面这样使用

numbers = [1, 5, 6, 7]
print(numbers[1:2])  # [5]
numbers[1:2] = [2, 3, 4]  
print(numbers)  # [1, 2, 3, 4, 6, 7]

在某个位置前插入新的元素

numbers = [1, 5, 6, 7]
print(numbers[1:1])  # []
numbers[1:1] = [2, 3, 4]
print(numbers)  # [1, 2, 3, 4, 5, 6, 7]

其实切片也可以是一个对象`slice(start, stop, step)`
>>> letters = ["A", "a", "B", "b", "C", "c", "D", "d"]

>>> upper_letters = letters[slice(0, None, 2)]
>>> upper_letters
['A', 'B', 'C', 'D']

>>> lower_letters = letters[slice(1, None, 2)]
>>> lower_letters
['a', 'b', 'c', 'd']

当不使用切片，而是使用索引时，再赋值可迭代对象，就是将可迭代对象本身替换到索引位置。

numbers = [1, 2, 3, 4]
numbers[2] = [5,6,7]
print(numbers)  # [1, 2, [5, 6, 7], 4]

list.append(): 用于向列表末尾填加一个元素

pets = ['cat', 'dog', 'parrot', 'gold fish', 'python']
pets.append('hawk')
print(pets)

pets.append(["hamster", "turtle"])
print(pets)

输出结果：

['cat', 'dog', 'parrot', 'gold fish', 'python', 'hawk']
['cat', 'dog', 'parrot', 'gold fish', 'python', 'hawk', ['hamster', 'turtle']]

list.extend(): 此函数也可以将一个可迭代对象里的元素扩展到列表中

fruits = ["apple", "pear", "peach"]
fruits.extend(["orange", "mango", "banana"])
print(fruits)  # ['apple', 'pear', 'peach', 'orange', 'mango', 'banana']

我们也可以通过切片实现

fruits = ["apple", "pear", "peach"]
fruits[len(fruits):] = ["orange", "mango", "banana"]
print(fruits)  # ['apple', 'pear', 'peach', 'orange', 'mango', 'banana']

list.insert(index, item): 在指定的位置前插入元素。注意，当插入可迭代对象时，并不会将其内容展开，而是直接做为可迭代对象整体插入。

letters = ["A", "B", "F", "G"]
letters.insert(2, ["C", "D"])
print(letters)  # ['A', 'B', ['C', 'D'], 'F', 'G']

如下是使用切片的效果对比

letters = ["A", "B", "F", "G"]
letters[2:2] = ["C", "D"]
print(letters)  # ['A', 'B', 'C', 'D', 'F', 'G']

如果非要用切片来进行等价实现，可以像下面这样

letters = ["A", "B", "F", "G"]
letters[2:2] = [["C", "D"]]
print(letters)  # ['A', 'B', ['C', 'D'], 'F', 'G']

三种移除元素的方法
list.remove(item): 移除列表中第一次出现的内容为item的元素。
list.pop(index): 移除列表中下标为index对应位置的元素，并将其做为函数的返回值。不传参时默认移除最后一个元素。
list.clear(): 清空列表中的所有元素。可以对应用切片实现list[:]=[]
内置函数del()同样可以移除列表中元素。

>>> colors = [
...     "red",
...     "orange",
...     "yellow",
...     "green",
...     "blue",
...     "indigo",
...     "violet"
... ]

>>> del colors[1]
>>> colors
['red', 'yellow', 'green', 'blue', 'indigo', 'violet']

>>> del colors[-1]
>>> colors
['red', 'yellow', 'green', 'blue', 'indigo']

>>> del colors[2:4]
>>> colors
['red', 'yellow', 'indigo']

>>> del colors[:]
>>> colors
[]

使用+, +=操作列表连接: 注意，两个列表相"+"，会返回一个新的列表，且有一个新的id。但extend函数不会改变列表的id。使用"+="也不会改变列表的id。

letters = ["A", "B", "F", "G"]
print(id(letters))

letters.extend(['c','d'])
print(id(letters))
print(letters)

letters += ['E','K']
print(id(letters))
print(letters)

letters = letters + ['H','M']

print(id(letters))
print(letters)

输出结果：

2110180053696
2110180053696
['A', 'B', 'F', 'G', 'c', 'd']
2110180053696
['A', 'B', 'F', 'G', 'c', 'd', 'E', 'K']
2110180849600
['A', 'B', 'F', 'G', 'c', 'd', 'E', 'K', 'H', 'M']

从输出结果可以看出，extend函数和"+="操作符都不会改变原列表的id。

使用*,*=可以重复列表内容: 此功能用法与+，+=相同。

letters = ["A", "B", "C"]
print(letters)
print(id(letters))

letters *= 2
print(letters)
print(id(letters))

letters = letters *2
print(letters)
print(id(letters))

输出结果：

['A', 'B', 'C']
2253659984576
['A', 'B', 'C', 'A', 'B', 'C']
2253659984576
['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']
2253661370880

列表的反转和排序: 即可以使用内置函数sorted和reverse，也可以使用list类的sort和reserve方法。但是内置reversed函数返回的是一个新的迭代器，而使用list类自己的方法，则直接改变原列表。

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> reversed(digits)
<list_reverseiterator object at 0x10b261a50>

>>> list(reversed(digits))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

>>> digits
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> digits.reverse()
>>> digits
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

还可以用切片来实现反转。

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> digits[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

使用内置sorted函数排序，返回的不是迭代器，而是一个新列表。

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

>>> sorted(numbers)
[1, 2, 5, 6, 9]

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

列表的比较: 通常没有太多意义，但仍然支持这么操作。比较时按照对应的元素位置比较，如果相等，再继续比较下一个，否则直接返回bool值
长度一样的列表之间的比较。

>>> [2, 3] == [2, 3]
True
>>> [5, 6] != [5, 6]
False

>>> [5, 6, 7] < [7, 5, 6]
True
>>> [5, 6, 7] > [7, 5, 6]
False

>>> [4, 3, 2] <= [4, 3, 2]
True
>>> [4, 3, 2] >= [4, 3, 2]
True

长度不一样的列表也能比较。

>>> [5, 6, 7] < [8]
True

>>> [5, 6, 7] == [5]
False

列表的性能：
使用下标或切片访问元素速度非常快。 因为列表是一块连续的内存区域，所有位置的元素通过下标访问时都解析为针对下标0的内存地址的一个偏移量，即可以立即定位到目标的内存地址。时间复杂度为O(1)
index和count函数运行时需要遍历每个元素，当列表元素很多时，性能很差。时间复杂度为O(n)
len()来求长度时间复杂度为O(1)，因为它并不是要遍历元素才知道元素个数，而是在对列表的创建及修改时会及时修改其长度属性。
append()，在列表内存够大时，时间复杂度为O(1)，但当列表空间不够时，python自动扩容(成倍增加内存)，有可能因为没有足够多的连续内存空间，牵扯到垃圾回收等复杂问题，所以性能就不高了。
insert()，当列表数据很多时，insert如果插入在比较靠前边的位置，后面位置都需要移动，效率很低。所以实际性能跟插入位置有关。
extend()函数相当于循环多次调用append，所以性能取决于要扩展的元素多少。
列表相加时，L1 + L2，不等同于Li.extend(L2)，而是返回一个全新的列表。相当于把原来每个列表的元素拿出来填加到一个新列表中。
列表乘以一个数就等同于重复的列表相加。
remove(value)，因为传入的参数是元素值，所以需要遍历，因此效率不同，而且后面元素还有移动，所以效率很差。
pop()，不带参数时移除属部元素，效率算高的，当然也可能涉及到重新计算内存，回收掉多余内存。 但如果传入位置参数，则效率很低，因为如果移除前面的元素，后面的元素都要移动位置。
clear()，效率高，清空列表数据。
成员检测 a in list 因为需要遍历，所以效率不高。O(n)