1.python-list

sequence-list

sequence-list
- - 通用操作
  - 序列操作函数
list

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)返回True
any()	#  如果有一个为 True，则返回 True。

sorted(iter,reverse=)
sorted(iter,key=)

range(start,stop,step) 
默认start=0,step=1

reverse()
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) 向列表中添加一个对象object
list.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)  # 找出某个值第一个匹配项的索引位置，如果都没有会报错 ValueError

list1 = [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]
d
c
['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*x
multiples = [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]

# 列表推导式和if else 用法
def squared1(x):
    return x*2

def squared2(x):
    return x*3 
multiples = [squared1(i)  if i%2==0 else squared2(i)  for i in range(30)]
print(multiples)
# [0, 3, 4, 9, 8, 15, 12, 21, 16, 27, 20, 33, 24, 39, 28, 45, 32, 51, 36, 57, 40, 63, 44, 69, 48, 75, 52, 81, 56, 87]

其他操作

列表去重

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)   # 使用了 key
print(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 Counter
Counter([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 itertools
out = 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)
#列表不可以转为字典

posted @ 2021-06-27 22:52 贝壳里的星海阅读(96) 评论(0) 编辑收藏举报

刷新页面返回顶部

贝壳里的星海