python-list

概述Sequence-list目录Sequence-list通用 *** 作序列 *** 作函数list常用 *** 作创建列表追加扩展查找访问删除元素列表排序列表推导式其他 *** 作列表去重相同不同元素统计列表中的重复项将嵌套列表展成一维list,tuple转换sequence(序列)是一组有顺序的元素的集合，序列可以包含一个或多个元素，也 Sequence-List

目录Sequence-list通用 *** 作序列 *** 作函数list常用 *** 作创建列表追加扩展查找访问删除元素列表排序列表推导式其他 *** 作列表去重相同不同元素统计列表中的重复项将嵌套列表展成一维list,tuple转换

sequence(序列)是一组有顺序的元素的集合，序列可以包含一个或多个元素，也可以是一个没有任何元素的空序列，元素可以是基本数据类型，可以是另一个序列，还可以是他对象。

sequence 就是一个 iterable 对象；

定义了__getitem__方法，支持使用 整数 索引进行有效的元素访问；

定义了一个__len__方法，该方法返回序列的长度；

一些内置的 squence 类型有：List，str，tuple

dict 类型也支持__getitem__和__len__，但它不是序列，因为访问 dict 的元素使用了 key（不可变类型）而不是 整数。

通用 *** 作

运算	结果：	注释
x in s	如果 s 中的某项等于 x 则结果为 True，否则为 False , 针对str 可以用来子序列检测
x not in s	如果 s 中的某项等于 x 则结果为 False，否则为 True，针对str 可以用来子序列检测
s + t	s 与 t 相拼接，拼接不可变序列会生成新的对象，开销大，可以尝试 Json,append
s * n 或 n * s	相当于 s 与自身进行 n 次拼接， 自身拼接, 修改其一，其他也改变	（1）
s[i]	s 的第 i 项，起始为 0	可为负
s[i:j]	s 从 i 到 j 的切片	（2）
s[i:j:k]	s 从 i 到 j 步长为 k 的切片	K!=0
len(s)	s 的长度
min(s)	s 的最小项
max(s)	s 的最大项
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数

(1) s * n

小于 0 的 n 值会被当作 0 来处理 (生成一个与 s 同类型的空序列)。 请注意序列 s 中的项并不会被拷贝；它们会被多次引用

>>> Lists = [[]] * 3   # 相当于自身的多次拼接>>> Lists[[], [], []]>>> Lists[0].append(3)>>> Lists[[3], [3], [3]]# [[]] * 3 结果中的三个元素都是对这一个空列表的引用。 修改 Lists 中的任何一个元素实际上都是对这一个空列表的修改,# 正确的的写法>>> Lists = [[] for i in range(3)]>>> Lists[0].append(3)>>> Lists[1].append(5)>>> Lists[2].append(7)>>> Lists[[3], [5], [7]]

（2）s[i:j]

索引时，s从i到j的切片被定义为所有满足 i <= k < j 的索引号k项组成的序列。如果i或j大于len(s)，则使用len(s)。如果i 被省略或为None,则使用0。 如果j被省略或为None，则使用len(s)。如果i大于等于j,则切片为空。

格式： [start:end:step]

[:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串

[start:] 从start 提取到结尾

[:end] 从开头提取到end - 1

[start:end] 从start 提取到end - 1

[start:end:step] 从start 提取到end - 1，每step 个字符提取一个

如果 start 大于等于end ,则切片为空。

序列 *** 作函数

all()   # iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回Trueany()	#  如果有一个为 True，则返回 True。sorted(iter,reverse=)sorted(iter,key=)range(start,stop,step) 默认start=0,step=1reverse()zip([iter],[iter])  将可迭代对象打包enumerate(sequence, start)将可迭代对象组合为一个索引序列，同时列出数据和下标

List

List([iterable])

列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表是一个数据的集合，集合内可以放任何数据类型，可对集合方便的增删改查 *** 作。Python已经内置确定序列的长度以及确定最大和最小的元素的方法

常用 *** 作

List=[]# 查找List.count(self,value) 			        # 统计某个元素在列表中出现的次数List.index(self, value, start=None, stop=None)  # 从列表中找出某个值第一个匹配项的索引位置，如果都没有会报错 ValueError# 增加List.append(self,p_object)   	                # 追加,可以追加元素，也可以追加列表[]List.extend(self,iterable) 	 	        # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）List.insert(self,index,start=None,stop=None) 	# 将对象插入列表# 移除del a_List[2]List.pop(self,index=None) 	# 移除列表中的一个元素（默认最后一个），并返回该元素的值List.remove(self,value) 	# 移除列表中某个值的第一个匹配项，从左找到第一个指定元素# 排序List.reverse(self,value) 	        # 反向列表中的元素List.sort(self,key=None,reverse=False) 	# 对原列表进行排序# 复制和清空List.clear(self) 				# 清空列表中的元素List.copy(self) 				# 浅复制列表

创建列表

a_List = [1,2,3,4,5,6]b_List = ['a','b','c','d']c_List = ['a','b','c',1,2,3,4]

追加扩展List.append(object) 向列表中添加一个对象objectList.extend(sequence) 把一个序列seq的内容添加到列表中

# 增加List.append(self,p_object)   	                # 追加,可以追加元素，也可以追加列表[]List.extend(self,iterable) 	 	        # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）List.insert(self,index,start=None,stop=None) 	# 将对象插入列表a_List = [1,2,3,4,5,6]b_List = ['a','b','c','d']c_List = ['a','b','c',1,2,3,4]a_List.append(8)b_List.extend(['e'])c_List.insert(1,'w')print(a_List)print(b_List)print(c_List)输出：[1, 2, 3, 4, 5, 6, 8]['a', 'b', 'c', 'd', 'e']['a', 'w', 'b', 'c', 1, 2, 3, 4]

查找访问

# 查找List.count(self,value) 			        # 统计某个元素在列表中出现的次数List.index(self, value, start=None, stop=None)  # 找出某个值第一个匹配项的索引位置，如果都没有会报错 ValueErrorList1 = [1,2,3,4,5,6]List2 = ['a','b','c','d']print(List1[0])print(List2[1:3])print(List1.index(4))输出：1['b', 'c']3

删除元素

del a_List[2]List.pop(self,index=None) 	# 移除列表中的一个元素（默认最后一个），并返回该元素的值List.remove(self,value) 	# 移除列表中某个值的第一个匹配项，从左找到第一个指定元素a_List = [1,2,3,4,5,6]b_List = ['a','b','c','d']c_List = ['a','b','c',1,2,3,4,1]del a_List[2]print(a_List)b = b_List.pop()print(b)d = c_List.remove(1)print(c_List)输出[1, 2, 4, 5, 6]dc['a','b','c',2,3,4,1]

列表排序

# 排序List.reverse(self,value) 	        # 反向列表中的元素List.sort(self,key=None,reverse=False) 	# 对原列表进行排序new_List=sorted(List)		        # 内置排序函数,返回列表newinter = reversed(List)	        # 内置反转函数，返回迭代器    a_List = ["1","?","123","w","W"]b_List = [5,3,7,1,8,9,2,4]c_List=[3, 5, 1, 4, 2]d_List=[1,2,3,4,5]a_List.sort()                          # 永久性排序，改变原有列表,没有返回值bl =sorted(b_List)    	               # 临时性排序，不改变原有列表，而是赋值给新的列表c_List.reverse()diter=reversed(d_List)print(a_List)print(bl)print(c_List)print(diter)输出：['1', '123', '?', 'W', 'w'][1, 2, 3, 4, 5, 7, 8, 9][2, 4, 1, 5, 3]<List_reverseiterator object at 0x000002642AA16908>

列表推导式

列表遍历列表List=['1','2','3']for value in List:		    print(value)	    for index,Listv in enumerate(List,start=0):    print(index,Listv)        # 逻辑上相当于一个循环，只是形似更加简洁[i for i in  range()][i for i in iterable]# 比如a_range = range(10)a_List = [x * x for x in a_range]print(a_List)# [0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]# 利用两层 for 循环将嵌套列表平铺成一个列表vec = [[1,2,3],[4,5,6], [7,8,9]]flat_vec = [num for elem in vec for num in elem]print(flat_vec)  [1, 2, 3, 4, 5, 6, 7, 8, 9]# 也可以写成函数形式def squared(x):    return x*xmultiples = [squared(i) for i in range(30) if i % 3 is 0]print multiples#  Output: [0, 9, 36, 81, 144, 225, 324, 441, 576, 729]

其他 *** 作列表去重

IDs = [1,4,3,3,4,2,3,4,5,6,1]IDs = List(set(IDs))            # set# set 保存源顺序numbers = [1,7,3,2,5,6,2,3,4,1,5]new_numbers = List(set(numbers))new_numbers.sort(key=numbers.index)   # 使用了 keyprint(new_numbers)输出：[1, 7, 3, 2, 5, 6, 4]

相同不同元素

a_List=[1,2,3,4]b_List=[1,5,6]# 返回两个列表中相同的元素和不同的元素# 方法一set1 = set(a_List)set2 = set(b_List)print(set1 & set2)print(set1 ^ set2)print(set1 | set2)输出：{1}				# 两者相同元素{2, 3, 4, 5, 6}			# 两者不同的元素{1, 2, 3, 4, 5, 6}              # 合# 方法二c=[x for x in a_List if x in b_List]d=[y for y in (a_List+b_List) if y not in c]print(c)print(d)

统计列表中的重复项

# 方法一myList = [1,2,2,2,2,3,3,3,4,4,4,4]#myset是另外一个列表，里面的内容是myList里面的无重复项myset = set(myList)  for item in myset:   res = myList.count(item)   print("the %d has found %d" %(item,myList.count(item)))    # 方法二from collections import CounterCounter([1,2,2,2,2,3,3,3,4,4,4,4])Counter({1: 5, 2: 3, 3: 2})

将嵌套列表展成一维

#方法一List1=[[1,2],[3,4],[5,6]]a_List = [[1,2,3],[4,5,6], [7], [8,9]]new_List=sum(a_List,[])# 方法二import itertoolsout = List(itertools.chain.from_iterable(a_List))# 方法三a = [[1,2,3], [5, 2, 8], [7,8,9]]List(np.ravel(a))# 方法四def expand_List(nested_List):    for item in nested_List:        if isinstance(item, (List, tuple)):            for sub_item in expand_List(item):                yIEld sub_item        else:            yIEld item

List,tuple转换

直接声明的List和tuple无法通过dict()转换成dict类型

tup=(1, 2, 3, 4, 5,6,7,8)#元组转为字符串tup.__str__()#元组转为列表List(tup)

nums=[1, 3, 5, 7, 9, 11, 13]#列表转为字符串str(nums)#列表转为元组tuple(nums)#列表不可以转为字典

总结

以上是内存溢出为你收集整理的python-list全部内容，希望文章能够帮你解决python-list所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。