<1> Python for Data Analysis — 数据结构、函数和文件 — 列表

列表

列表：与元组不同，列表的长度是可变的，它包含的内容是可以修改的

（1）可以使用 [ ]或者list类型函数来定义列表。例如：

a_list = [2,3,4,5]
b_list = list(('foo','bar','baz'))
print(type(b_list)) # 结果为列表
print(b_list[1]) # 结果为 bar

（2）list 函数在数据处理中常用于将迭代器或生成器转换为列表，例如：

#list函数在数据处理中常用于将迭代器或生成器转换为列表，例如
a = range(10)
print(list(a))

（3）列表中元素的增加：使用append方法可以将元素添加到列表的尾部

#列表中增加和移动元素：使用append方法可以将元素添加到列表的尾部
a = list(('foo','bar','baz'))
a.append('dwarf')
print(a)

（4）列表中元素的增加：使用insert方法可以将元素插入到指定的列表位置。例如下面的代码的输出结果为：['foo', 'red', 'bar', 'baz']

a = list(('foo','bar','baz'))
a.insert(1,'red')
print(a)

注意：insert与append相比，计算代价更高。

（5）列表中元素的删除：insert的反操作是pop，该操作会将特定位置的元素移除并返回。下面代码结果为：['foo', 'bar']

# insert的反操作是pop，该操作会将特定位置的元素移除并返回
a = list(('foo','bar','baz'))
a.pop(2)
print(a)

（6）列表中元素的删除：元素的删除可以通过remove方法移除，该方法会定位第一个符合要求的值并移除它。下面代码结果为：['a', 'b', 'c']

# 元素可以通过remove方法移除，该方法会定位第一个符合要求的值并移除它
a = ['a', 'b', 'c', 'c']
a.remove('c')
print(a)

（7）使用in（或not in）关键字可以检查一个值是否在列表中。下面代码结果都为Ture。

# 使用in关键字可以检查一个值是否在一个列表中;使用 not in 表示不在
print('a'in a)
print('d' not in a)

与字典、集和相比，检查列表中是否包含一个值是非常缓慢的！

（8）连接和联合列表：与元组类似，两个列表可以使用+号连接。下面代码结果为：[4, None, 'foo', 7, 2, (2, 3)]

a = [4,None,'foo']
b = [7,2,(2,3)]
c = a + b
print(c)

(9）连接和联合列表：如果我们已经定义了一个列表，可以使用extend方法向该列表中添加多个元素。下面代码结果为：[4, 1, 'foo', 5, 6, (9, 8)]

a = [4,1,'foo']
a.extend([5,6,(9,8)])
print(a)

(10）排序：可以调用列表的sort方法对列表进行内部排序（无须新建一个对象）。下面代码结果为：[1, 1, 2, 3, 5, 6, 7]

a = [7,1,2,5,6,1,3]
a.sort()
print(a)

         排序：sort可以传递一些参数key，即根据字符串的长度进行排序。下面代码结果为：['c', 'ba', 'abc', 'jacke']

a = ['ba','abc', 'c','jacke']
a.sort(key=len)
print(a)

(11）二分搜索和已排序列表的维护：内建的bisect模块实现了二分搜索和已排序列表的插值。

bisect.bisect会找到元素应当被插入的位置，并保持序列排序。例如下面的结果分别打印出：10, [1, 2, 3, 3, 4, 5, 5, 5, 6, 7]

a = [1,2,3,3,4,5,5,5,6,7]
print(bisect.bisect(a,8))
print(a)

而bisect.insort将元素插入到相应位置。例如下面的结果将打印出[1, 2, 3, 3, 4, 5, 5, 5, 6, 7, 8]

bisect.insort(a,8)
print(a)

(12）切片：使用切片符号可以取子集，例如下面代码的结果为：[4, 2, 6, 6]

# 使用切片符号可以对大多数序列类型取其子集，它的基本形式是将Start：stop传递到索引符号[]中
a = [1,3,4,2,6,6,7]
c = a[2:6]
print(c)

注意：索引取子集是包左不包右。

start和stop是可以省略的，如果省略默认是传入序列的起始位置或结束位置。例如下面代码的结果分别为：[4, 2, 6, 6, 7]和[1, 3, 4, 2]

a = [1,3,4,2,6,6,7]
d = a[2:]
print(d)
e = a[:4]
print(e)

负索引可以从序列的尾部进行索引：例如下面代码的结果为[2, 6, 6]

a = [1,3,4,2,6,6,7]
b = a[-4:-1]
print(b)

步进值step可以在第二个人冒号后面使用，意思是每隔多少个数值取一个值。例如下面代码的结果为[1, 4, 6, 7]

a = [1,3,4,2,6,6,7]
b = a[::2]
print(b)

当需要对列表或元组进行翻转时，可以向step中传递-1。例如下面代码的结果为[7, 6, 6, 2, 4, 3, 1]

# 当需要对列表或元组进行翻转时，可以向step中传递-1
a = [1,3,4,2,6,6,7]
b = a[::-1]
print(b)

(13）内建序列函数: enumerate ---->当我们需要对数据建立索引时，一种有效的模式就是使用enumerate构造一个字典，将序列值mapping到索引位置上。例如下面代码输出结果为：{'dog': 0, 'cat': 1, 'monkey': 2, 'pandas': 3}

a = ['dog','cat', 'monkey','pandas']
mapping = {}
for i,v in enumerate(a):
    mapping[v] = i
print(mapping)

(13）内建序列函数: sorted ---->返回一个根据任意序列中元素新建的已排序列表。下面代码的结果为：[1, 2, 3, 2, 1, 5, 3, 8]

# sorted函数-----> 返回一个根据任意序列中元素新建的已排序列表：
a = [1,2,3,2,1,5,3,8]
print(sorted(a))

(14）内建序列函数: zip ---->将列表、元组或其他序列的元素配对，新建一个元组构成的列表。zip可以处理任意长度的序列，它生成的列表长度由最短序列决定。下面代码的打印结果分别为：[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]和[('foo', 'one', False), ('bar', 'two', True)]

a = ['foo','bar','baz']
b = ['one','two','three']
c = [False,True]
d_zip = list(zip(a,b))
print(d_zip)
e_zip = list(zip(a,b,c))
print(e_zip)

zip的常用场景为同时遍历多个序列，有时会和enumerate同时使用。下面代码的打印结果分别为：

0:foo,one
1:bar,two
2:baz,three
3:dog,four

# zip 的常用场景为同时遍历多个序列，有时候会和enumerate同时使用：
a = ['foo','bar','baz','dog']
b = ['one','two','three','four']
for i, (a,b) in enumerate(zip(a,b)):
    print('{0}:{1},{2}'.format(i,a,b))

zip也可以用于解压，例如下面的代码的输出结果为：('nolan', 'Roger', 'Dwf')和('yuan', 'Cleans', 'fwg')

name = [('nolan','yuan'),('Roger','Cleans'),('Dwf','fwg')]
first_name, last_name = zip(*name)
print(first_name)
print(last_name)

(15）内建序列函数: reversed 函数是将序列的元素倒序排列。例如下面的代码的输出结果为：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

a = list(reversed(range(10)))
print(a)

注意：reversed 是一个生成器，因此如果没有实例化（例如使用list函数或进行for循环）的时候，它将不会产生一个倒序的列表。