Python之列表详解

原创

mob604756fa4732 2021-05-09 15:27:39 ©著作权

文章标签 java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob604756fa4732的原创作品，请联系作者获取转载授权，否则将追究法律责任

列表

列表（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。

列表是一组有序项目的集合 ,可变的数据类型【可进行增删改查】; 列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】列表是以方括号“”包围的数据集合，不同成员以“,”分隔列表可通过序号访问其中成员.

1、创建列表

>>> names = ['lucky', 'jack', 'tom', 'jim', 'erica']    #方法一
>>> print(names)['lucky', 'jack', 'tom', 'jim', 'erica']

>>> names = list(('jason', 'chris', 'andy', 'sunny', 'sun'))   #方法二
>>> print(names)['jason', 'chris', 'andy', 'sunny', 'sun']

2、访问元素
通过下标访问列表中的元素，下标从0开始计数

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1]
'UI'
>>> jobs[2]
'UE'
>>> jobs[4]
'DBA'
>>> jobs[-2]   # 还可以倒数着来，不过下标从-1开始
'DBA'

3、列表切片

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[1:4]   # 取下标从1到4的元素，但是不包括4，列表切片的特征就是左开右闭，也就是左取右弃。['UI', 'UE', 'OPS']
>>> jobs[1:-1]  # 取下标为1到-1的元素，不包括-1，也就是最后一个元素不会被取出来。['UI', 'UE', 'OPS', 'DBA']
>>> jobs[:]    # 这个在切片符左右没有下标限制，所以就是代表全取['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[::]   # 效果和上面一样，但是你会发现有两切片符，这是因为切片有一个步长的概念['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[0:3]  # 取下标0到3的元素，但不包括3['PM', 'UI', 'UE']
>>> jobs[:3]   # 和上面效果一样['PM', 'UI', 'UE']
>>> jobs[3:]   # 从下标3开始，到最后一个元素['OPS', 'DBA', 'DEV']
>>> jobs[3:-1] # 从下标3开始，到最后一个元素，但是不包括最后一个元素['OPS', 'DBA']
>>> jobs[0::2] # 从下标0开始，按照2个步长取值['PM', 'UE', 'DBA']
>>> jobs[::2]  # 和上面效果一样['PM', 'UE', 'DBA']

利用下标取出的一个单独元素是str类型，而利用分片取出的是一个list类型。

4、列表追加

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.append('QA')  #添加到最后
>>> jobs['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'QA']

5、列表插入

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(2, 'Sales')   # 从下标为2的元素后面插入，其实可以理解为我插入一个元素，下标为3
>>> jobs['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.insert(-1, 'QA')     # 也可以倒数着来
>>> jobs['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'QA', 'DEV']

6、修改元素

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs[2] = 'QA'  # 把下标为2的元素替换成QA，根据下标然后给元素重新赋值
>>> jobs['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV']
>>> jobs[-2] = 'Sales'  # 把下标为12的元素替换成Sales，根据下标然后给元素重新赋值
>>> jobs['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']

7、删除元素

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> del jobs[-1]  # del方法删除最后一个元素
>>> jobs['PM', 'UI', 'UE', 'OPS', 'DBA']
>>> del jobs[1]  # del方法删除下标为1的元素
>>> jobs['PM', 'UE', 'OPS', 'DBA']
>>> jobs.remove("DBA") # 根据remove方法，指定你想删除的元素
>>> jobs['PM', 'UE', 'OPS']
>>> jobs.pop()   # pop方法，默认删除最后一个，返回删除元素
'OPS'
>>> jobs['PM', 'UE']
>>> jobs.pop(0) # pop还可以指定元素下标，指定删除
'PM'
>>> jobs['UE']
>>> jobs.clear() # clear 删除列表所有的元素，就是清空列表，变成为一个空列表
>>> jobs[]

remove方法删除一个元素，必须是在列表中的，否则会报错，del利用下标来删除元素，pop默认删除最后一个元素，也可以指定元素下标来删除。

8、扩展列表

>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> job = ['Sales', 'QA', 'HR']
>>> jobs.extend(job)  # extend方法就是把job列表里面的元素一个个添加到jobs列表中。
>>> jobs['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'Sales', 'QA', 'HR']

9、列表拷贝

>>> jobs['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs_copy = jobs.copy()   # 复制一份jobs列表
>>> jobs_copy['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]   # 嵌入式列表
>>> jobs_copy2 = jobs.copy()
>>> jobs_copy2['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]
>>> jobs[0] = 'HR' # 改变小标为0的元素
>>> jobs['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]  # 改变了
>>> jobs_copy2['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]  # 没变
>>> jobs[-1][0] = 'Sales'  # 改变内嵌列表的下标为0的元素
>>> jobs['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']]  # 改变了
>>> jobs_copy2['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']]  # 改变了

从上面可以看出列表的copy方法是一个浅copy的栗子，只会拷贝第一次，而多层嵌入的话，会随着源列表的变化为变化，关于深拷贝和浅拷贝后面详细介绍。

10、列表统计

>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.count('OPS')  # 因为列表是有序的一种数据类型，所以它的元素是可以重叠的，所以有元素统计。
2

11、排序和翻转

>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3]
>>> jobs.sort()
Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()          # Python3.0里不同数据类型不能放在一起排序了，擦
>>> jobs[-1] = '3'
>>> jobs[-2] = '2'
>>> jobs[-3] = '1'
>>> jobs['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3']
>>> jobs.sort()
>>> jobs['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
>>> jobs.append('#')
>>> jobs.append('&')
>>> jobs.sort()
>>> jobs['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']  # 可以看出排序的顺序 特殊字符->数字->字母 这么一个优先级
>>> jobs.reverse() # 翻转最后到最前面
>>> jobs['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']

sort()方法会修改原列表，而不是创建一个新的有序列表，reverse()也会修改原列表，但是你希望排序，但是又不希望修改原列表，你只能利用python中一个名为sorted()的内置函数来操作：

>>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist = sorted(jobs)
>>> jobs['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> newlist['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']

12、列表索引

>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE']
>>> jobs.index('OPS')
2
>>> jobs.index('UE')
3
>>> jobs.index('xx')
Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
ValueError: 'xx' is not in list
>>> if 'OPS' in jobs:
	...     print(jobs.index('OPS'))
	... 
	2

索引下标，只会返回第一个元素的下标,如果元素不在列表中，会报错，我们可以利用in这个关键之来判断元素是否在列表中。

列表所有的方法如下：

class list(object):
	"""
	list() -> new empty list
	list(iterable) -> new list initialized from iterable's items
	"""
	def append(self, p_object): # real signature unknown; restored from __doc__
		""" L.append(object) -> None -- append object to end """
		pass

	def clear(self): # real signature unknown; restored from __doc__
		""" L.clear() -> None -- remove all items from L """
		pass

	def copy(self): # real signature unknown; restored from __doc__
		""" L.copy() -> list -- a shallow copy of L """
		return []

	def count(self, value): # real signature unknown; restored from __doc__
		""" L.count(value) -> integer -- return number of occurrences of value """
		return 0

	def extend(self, iterable): # real signature unknown; restored from __doc__
		""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """
		pass

	def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
		"""
		L.index(value, [start, [stop]]) -> integer -- return first index of value.
		Raises ValueError if the value is not present.
		"""
		return 0

	def insert(self, index, p_object): # real signature unknown; restored from __doc__
		""" L.insert(index, object) -- insert object before index """
		pass

	def pop(self, index=None): # real signature unknown; restored from __doc__
		"""
		L.pop([index]) -> item -- remove and return item at index (default last).
		Raises IndexError if list is empty or index is out of range.
		"""
		pass

	def remove(self, value): # real signature unknown; restored from __doc__
		"""
		L.remove(value) -> None -- remove first occurrence of value.
		Raises ValueError if the value is not present.
		"""
		pass

	def reverse(self): # real signature unknown; restored from __doc__
		""" L.reverse() -- reverse *IN PLACE* """
		pass

	def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
		""" L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
		pass

13、列表的遍历
在Python中常用循环对象来遍历列表，在这里for循环自动调用next()方法，将该方法的返回值赋予给循环对象i。循环检测到StopIteration的时候才结束。相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']

for i in jobs:
    print(i)  # 自动调用迭代器，自动检测StopIteration

# 在上面的程序中，无法知道当前访问元素的索引，于是有如下代码：
for i in range(len(jobs)):
    print(jobs[i])

# 同时需要索引，又结合迭代器，就可以采用内置的enumerate函数，代码如下：
for index, i in enumerate(jobs):
    print(index, i)

扩展：（表推导方法）
表推导(list comprehension)是快速生成列表的方法。它的语法简单，很有实用价值。

L = [x**2 for x in range(10)]
print(L)

Result:[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

zip函数
如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：

t1 = [1, 2, 3]
t2 = [9, 8, 7]
t3 = ['a', 'b', 'c']
for (a, b, c) in zip(t1, t2, t3):
    print(a, b, c)
    
Result：
1 9 a
2 8 b
3 7 c

每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple，然后tuple的元素赋予给a,b,c

#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

ShopName = ['iphone', 'MacPro', 'iWatch']
money = [5500, 12000, 3800]

Car = []
for it in zip(ShopName, money):
    Car.append(it)
print(Car)

Result:[('iphone', 5500), ('MacPro', 12000), ('iWatch', 3800)]

Python之列表详解_java