【Python】列表

最新推荐文章于 2022-10-11 21:48:47 发布
最新推荐文章于 2022-10-11 21:48:47 发布
阅读量620 收藏 3
点赞数
分类专栏： Python基础 文章标签： python 列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Graduate2015/article/details/117482546
版权

文章目录

前言
Python 列表
列表方法
列表操作
append
clear
copy
count
extend
index
insert
pop
remove
reverse
sort
基础操作
进阶操作
创建
访问
修改
增加
删除
遍历
成员资格
运算符
长度
最值
排序
TBD
TBD
TBD

1. 列表方法

1.1 append

list.append(obj)：在列表末尾添加新的对象

list1 = [1,2,3,4]
list1.append(5)
print(list1) # [1, 2, 3, 4, 5]
list1.append([6,7])
print(list1) # [1, 2, 3, 4, 5, [6, 7]]
list1.append(8,9) # TypeError: append() takes exactly one argument (2 given)

1.2 clear

list.clear()： 清空列表，类似于del list[:]

list1 = [1,2,3,4]
list1.clear()
print(list1) # []

1.3 copy

list.copy()：复制列表，类似于list[:]

list1 = [1,2,3,4]
list2 = list1.copy()
print(list2) # [1,2,3,4]

注释：list.copy()和直接通过“=”进行简单赋值的区别 [1]

  • list.copy()是浅拷贝，即拷贝父对象，不会拷贝对象的内部的子对象。通俗点讲，父对象指向不同的内存地址，因此是两个独立的对象，一方的改变不会影响另外一方；而子对象指向同一内存地址，因此是同一对象的引用，任一方的改变都会影响另外一方。
  • =：赋值引用，“=”左右对象指向同一内存地址，因此任一方的改变都会影响另外一方。

我们看一下下面的例子：

list1 = [1,[2,3],4,5]
list2 = list1 # 赋值引用
list3 = list1.copy() # 浅拷贝
list1[0] = -1 # list1在第一层的修改会影响list2，但不会影响list3
list2[2] = -4 # list2在第一层的修改也会影响list1，但不会影响list3
list3[3] = -5 # list3在第一层的修改不会影响list1和list2
list1[1][0] = -2 # list1在第二层的修改会影响list2，也会影响list3
list3[1][1] = -3 # list3在第二层的修改会影响list1，也会影响list2
print('list1:',list1) # list1: [-1, [-2, -3], -4, 5]
print('list2:',list2) # list2: [-1, [-2, -3], -4, 5]
print('list3:',list3) # list3: [1, [-2, -3], 4, -5]
print(id(list1),id(list1[0]),id(list1[1])) # 1650324110016 140722376156896 1650324109888
print(id(list2),id(list2[0]),id(list2[1])) # 1650324110016 140722376156896 1650324109888
print(id(list3),id(list3[0]),id(list3[1])) # 1650324110336 140722376156960 1650324109888

list.copy()和copy.copy(list)以及list[:]的效果一致。

1.4 count

list.count(obj)：统计某个元素在列表中出现的次数

list1 = [1,2,2,2,3,3,3,3]
print(list1.count(1)) # 1
print(list1.count(2)) # 3
print(list1.count(3)) # 4

# 元素值不在列表中也没关系
print(list1.count(4)) # 0

1.5 extend

list.extend(obj)：通过添加可迭代对象中的元素来扩展列表，可迭代对象可以是列表、元组、集合、字典，若为字典，则仅会将键（key）作为元素依次添加至原列表的末尾

list1 = [1,2,3]
list2 = [4,5] # 列表
list3 = (6,7) # 元组
list4 = {'a':8,'b':9} # 字典
list1.extend(list2)
print(list1) # [1, 2, 3, 4, 5]
list1.extend(list3)
print(list1) # [1, 2, 3, 4, 5, 6, 7]
list1.extend(list4)
print(list1) # [1, 2, 3, 4, 5, 6, 7, 'a', 'b']

1.6 index

list.index(obj[, start[, end]])：从列表中找出某个值第一个匹配项的索引位置。如果该值不存在，则会报错

  • obj：查找的对象
  • start：可选，查找的起始位置（包含）
  • end：可选，查找的结束位置（不包含）
list1 = [1,2,3,2,1,4,3,3,4,1,1,2]
print(list1.index(1)) # 0
print(list1.index(2)) # 1
print(list1.index(3)) # 2
print(list1.index(1,4)) # 4，从位置4开始（包含）查找值1
print(list1.index(1,5,10)) # 9，查找位置5（包含）到位置10（不包含）范围内的值1
print(list1.index(5)) # ValueError: 5 is not in list

1.7 insert

list.insert(index, obj)：在index之前将对象插入列表

list1 = [1,2,3]
list1.insert(0,-1)
print(list1) # [-1, 1, 2, 3]
list1.insert(1,-2)
print(list1) # [-1, -2, 1, 2, 3]
list1.insert(-3) # TypeValue: insert expected 2 arguments, got 1（需要指定index）

1.8 pop

list.pop([index=-1])：移除列表中index位置的元素（默认最后一个元素），并且返回该元素的值。如果列表为空或者index超出索引范围，则会报错

list1 = [1,2,3,4]
print(list1.pop()) # 4
print(list1.pop(0)) # 1
print(list1) # [2,3]
list1.pop(4) # IndexError: pop index out of range

1.9 remove

list.remove(obj)：移除列表中某个值的第一个匹配项。如果该值不存在，则会报错

list1 = [1,2,3,2,1,4,3,3,4,1,1,2]
list1.remove(1)
print(list1) # [2, 3, 2, 1, 4, 3, 3, 4, 1, 1, 2]
list1.remove(2)
print(list1) # [3, 2, 1, 4, 3, 3, 4, 1, 1, 2]
list1.remove(5) # ValueError: list.remove(x): x not in list

1.10 reverse

list.reverse()：对列表进行翻转

list1 = [1,2,3]
list1.reverse()
print(list1) # [3, 2, 1]

1.11 sort

list.sort(key=None, reverse=False)：对原列表进行排序

  • key：排序键值
  • reverse：排序顺序，reverse = True 降序， reverse = False 升序（默认）
list1 = [1,3,4,2]
list1.sort()
print(list1) # [1, 2, 3, 4]，升序排列
list1.sort(reverse=True)
print(list1) # [4, 3, 2, 1]，降序排列

2. 列表操作

2.1 基础操作

2.1.1 创建

2.1.1.1 []创建列表

[item1,item2,…]：列表的各个元素通过逗号分隔

# 创建空列表
list1 = []

# 赋值创建列表
# 列表里面可以放入任意数据类型
list2 = [1,2,3,4]
list3 = ['a','b','c','d']
list4 = [1,'a',[2],{'c':3},(4,5)]
2.1.1.2 list()创建列表

list(iterable)：返回一个列表，可选参数iterable是可迭代对象，如字符串、元组、字典、range对象等，若为字典，则会将字典的键（key）返回形成列表 [2]

# 创建空列表
list1 = list() 
print(list1) # []

# 从字符串创建列表
list2 = list('python')
print(list2) # ['p', 'y', 't', 'h', 'o', 'n']
# 从元组创建列表
list3 = list((1,2,3))
print(list3) # [1, 2, 3]
# 从字典创建列表
list4 = list({'a':1,'b':2,'c':3})
print(list4) # ['a', 'b', 'c']
# 从range对象创建列表
list5 = list(range(10))
print(list5) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 单个数值无法直接创建列表，因为单个数值不是可迭代对象
list(6) # TypeError: 'int' object is not iterable
2.1.1.3 循环创建列表
# 通过list.append()循环创建列表
list1 = []
for i in range(10):
    list1.append(i)
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 通过“+”循环创建列表
list2 = []
for i in range(10):
    list2 += [i] # list2 = list2+[i]
print(list2) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2.1.1.4 列表推导式/生成式

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]，if条件表达式为可选参数

list1 = [x for x in range(10)]
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list2 = [2*x+1 for x in range(10)]
print(list2) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

list3 = [x for x in range(20) if x%2==1]
print(list3) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

# 上面list3表达式是下面for循环和if条件表达式的变种
list4 = []
for x in range(20):
    if x%2==1:
        list4.append(x)
print(list4) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

注释：列表推导式本质上还是for循环的变种

2.1.2 访问

2.1.2.1 索引

正向索引（从左往右）：索引0开始，0（第1个元素）, 1（第2个元素）, 2（第3个元素）, …
反向索引（从右往左）：索引-1开始，…,-1（倒数第1个元素）,-2（倒数第2个元素）,-3（倒数第3个元素）

list1 = [1,2,3,4,5,6,7,8,9,10]
print(list1[0]) # 1
print(list1[1]) # 2
print(list1[-1]) # 10
print(list1[-2]) # 9
print(list1[10]) # IndexError: list index out of range

list2 = [1,[2,3],'a']
print(list2[0]) # 1
print(list2[1]) # [2,3]
# 如果需要进一步对[2,3]进行索引
print(list2[1][0]) # 2 
print(list2[1][1]) # 3
2.1.2.2 切片

list[start: end :step]

  • start：起始索引（包含），默认为0
  • end：结束索引（不包含），默认为-1
  • step：步长（默认为1），步长为正时，从左向右取值；步长为负时，从右向左取值
  • 当步长为正时，start要比end先出现；当步长为负时，start要比end晚出现
list1 = [1,2,3,4,5,6,7,8,9,10]

# 选取从第1位开始，到最后1位结束的所有元素（不包含最后1位）
print(list1[0:9]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 选取从第1位开始，到最后1位结束的所有元素（不包含最后1位）
print(list1[0:-1]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 选取所有元素，常用来拷贝列表，等同于list.copy()
print(list1[:]) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 选取所有元素
print(list1[0:]) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 选取最后1位之前的所有元素（不包含最后1位）
print(list1[:-1]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 选取最后3位元素
print(list1[-3:]) # [8, 9, 10]

# 选取从第1位开始，到最后1位结束的所有元素（不包含最后1位），显示表达步长
print(list1[0:9:1]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 从第1位开始，到最后1位结束，隔1个挑选1个元素（不包含最后1位）
print(list1[0:9:2]) # [1, 3, 5, 7, 9]
print(list1[0::2]) # [1, 3, 5, 7, 9]
print(list1[:9:2]) # [1, 3, 5, 7, 9]
print(list1[::2]) # [1, 3, 5, 7, 9]

# 从最后1位开始的所有元素（相当于倒序）
print(list1[::-1]) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(list1[10::-1]) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(list1[-1::-1]) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 从最后1位开始，隔1个挑选1个元素
print(list1[::-2]) # [10, 8, 6, 4, 2]
print(list1[9::-2]) # [10, 8, 6, 4, 2]
print(list1[-1::-2]) # [10, 8, 6, 4, 2]

# 当步长为正时，start要比end先出现
print(list1[9:0:2]) # []

# 当步长为负时，start要比end晚出现
print(list1[0:9:-2]) # []

注释：
索引不可以超出列表范围，但是切片可以。

list1 = [1,2,3,4,5,6,7,8,9,10]

print(list1[10]) # IndexError: list index out of range
print(list1[:20]) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1[20:]) # []

2.1.3 修改

2.1.3.1 元素赋值
list1 = [1,2,3,4,5]

# 元素赋值，一次只能修改列表的一个元素
list1[0] = 0
print(list1) # [0, 2, 3, 4, 5]

# 元素赋值索引不能超出列表范围
list1[5] = [6] # IndexError: list assignment index out of range
2.1.3.2 切片赋值
list1 = [1,2,3,4,5]

# 切片赋值，一次可以修改列表的多个元素
list1[:3] = [0,1,2]
print(list1) # [0, 1, 2, 4, 5]

# 切片赋值，使用与原列表片段不等长的列表进行替换
list1[3:] = [3,4,5,6]
print(list1) # [0, 1, 2, 3, 4, 5, 6]

# 切片赋值，在列表末尾插入新的元素
list1[7:] = [7,8,9]
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 切片赋值，在列表中间插入新的元素
list1[3:3] = [1]*5
print(list1) # [0, 1, 2, 1, 1, 1, 1, 1, 3, 4, 5, 6, 7, 8, 9]

注释：
相较元素赋值，切片赋值非常强大，不仅可以一次性为多个元素赋值，而且可以使用与原列表片段不等长的列表进行替换，还可以“插入”新的元素。

2.1.4 增加

2.1.4.1 append

list.append(obj)：一次只能增加一个元素，无论元素是什么形式

list1 = [1,2,3,4]

# 一次增加一个数值元素
list1.append(5)
print(list1) # [1, 2, 3, 4, 5]

# 一次增加一个列表元素
list1.append([6,7])
print(list1) # [1, 2, 3, 4, 5, [6, 7]]

# 无法一次增加两个元素
list1.append(8,9) # TypeError: append() takes exactly one argument (2 given)
2.1.4.2 extend

list.extend(obj)：可一次性增加单个或多个元素，只要将单个或多个元素放入列表或元组的可迭代对象中，非常灵活

list1 = [1,2,3]
list2 = [4,5] # 列表
list3 = (6,7) # 元组
list4 = ['a','b']

# 将列表中元素一次性加入原列表中
list1.extend(list2)
print(list1) # [1, 2, 3, 4, 5]

# 将元组中元素一次性加入原列表中
list1.extend(list3)
print(list1) # [1, 2, 3, 4, 5, 6, 7]

# 如果只增加单个元素，也需要将该元素放入列表或元组这样的可迭代对象中
list1.extend([8])
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8]
list1.extend(8) # TypeError: 'int' object is not iterable

# extend可加入任何类型的元素
list1.extend(list4)
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b']
list1.extend('cde')
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', 'd', 'e']
2.1.4.3 连接操作“+”

连接操作“+”：和extend功能类似，支持多种可迭代对象

list1 = [1,2,3]
list2 = [4,5] # 列表
list3 = (6,7) # 元组
list4 = ['a','b']

# 将列表中元素一次性加入原列表中
list1 += list2 # 相当于list1 = list1 + list2
print(list1) # [1, 2, 3, 4, 5]

# 将元组中元素一次性加入原列表中
list1 += list3
print(list1) # [1, 2, 3, 4, 5, 6, 7]

# 如果只增加单个元素，也需要将该元素放入列表或元组这样的可迭代对象中
list1 += [8] 
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8]
list1 += 8

# “+”可连接任何类型的可迭代对象
list1 += list4
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b']
list1 += 'cde'
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', 'd', 'e']
2.1.4.4 切片赋值

参考2.1.3.2节。

2.1.4.5 insert

list.insert(index, obj)：在index之前将对象插入列表。insert方法一次只能在指定位置增加一个元素，因此没有切片赋值灵活，但可读性更高

list1 = [1,2,3,4,5]
list2 = [1,2,3,4,5]

# insert一次只能增加一个元素
list1.insert(2,[1,1])
print(list1) # [1, 2, [1, 1], 3, 4, 5]
list1.insert(2,1,1) # TypeError: insert expected 2 arguments, got 3

# 切片赋值一次可增加多个元素，非常灵活
list2[2:2] = [1,1]
print(list2) # [1, 2, 1, 1, 3, 4, 5]

2.1.5 删除

2.1.5.1 pop

参考1.8节。

2.1.5.2 remove

参考1.9节。

2.1.5.3 clear

参考1.2节。

2.1.5.3 del

del：del配合索引或切片

list1 = [1,2,3,4,5]

del(list1[1])
print(list1) # [1, 3, 4, 5]
del(list1[2:])
print(list1) # [1, 3]
2.1.5.4 切片赋[]

元素赋[]无法实现删除

list1 = [1,2,3,4,5,6]

list1[1] = []
print(list1) # [1, [], 3, 4, 5, 6]
 
list1[1:1] = []
print(list1) # [1, [], 3, 4, 5, 6]

list1[0:2] = []
print(list1) # [3, 4, 5, 6]

list1[2:] = []
print(list1) # [3, 4]

2.1.6 遍历

2.1.6.1 索引遍历
list1 = [1,2,3,4,5,6,7,8,9,10]

# 通过索引遍历（不推荐）
for index in range(len(list1)):
    print(index) # 0 1 2 3 4 5 6 7 8 9
    print(list1[index]) # 1 2 3 4 5 6 7 8 9 10
2.1.6.2 循环体遍历
list1 = [1,2,3,4,5,6,7,8,9,10]

# 通过列表循环体遍历（Pythonic的方式，推荐）
for item in list1:
    print(item) # 1 2 3 4 5 6 7 8 9 10

2.1.7 成员资格

in：检查一个值是否在序列（不仅仅是列表）中，返回布尔运算符

list1 = [1,[2,3],'a']
print(1 in list1) # True
print(2 in list1) # False
print([2,3] in list1) # True
print('a' in list1) # True
print(a in list1) # NameError: name 'a' is not defined

2.1.8 运算符

  • “+”：列表（不光光是列表，也包括其他序列类型）的连接，具体参考2.1.4.3节
  • ”*“：列表（不光光是列表，也包括其他序列类型）的重复
list1 = [1,2,3]
list2 = [4,5]

print(list1+list2) # [1, 2, 3, 4, 5]
print(list2*3) # [4, 5, 4, 5, 4, 5]

2.1.9 长度

len(seq)：内建函数len返回序列（不仅仅是列表）中所包含元素的数量

list1 = [1,2,3,4]
list2 = [1,2,[3,4]]
list3 = ['a','b','c','d']
print(len(list1)) # 4
print(len(list2)) # 3
print(len(list3)) # 4

2.1.10 最值

max(seq)：内建函数max返回序列（不仅仅是列表）中最大的元素
min(seq)：内建函数min返回序列（不仅仅是列表）中最小的元素

  • 当序列中元素全部为数字时，根据值的大小比较
  • 当序列中元素全部为字符串时，根据每个字符串元素每个字符的 ASCII 的大小比较 [3]
  • 当序列中元素为数字和字符串混杂时，则无法比较
# 当序列中元素全部为数字时，根据值的大小比较
list1 = [1,2,3,4]
print(max(list1)) # 4
print(min(list1)) # 1

# 当序列中元素全部为字符串时，根据每个字符串元素的第一个字符的 ASCII 的大小比较
list2 = ['I','love','you']
print(max(list2)) # you
print(min(list2)) # I
print(ord(list2[0][0])) # 73
print(ord(list2[1][0])) # 108
print(ord(list2[2][0])) # 121

# 当序列中元素为数字和字符串混杂时，则无法比较
list3 = [1,2,3,4,'I','love','you']
print(max(list3)) # TypeError: '>' not supported between instances of 'str' and 'int'
print(min(list3)) # TypeError: '>' not supported between instances of 'str' and 'int'

2.1.11 排序

2.1.11.1 sort方法

list.sort(key=None,reverse=False)：对原列表进行排序

  • key：排序键值
  • reverse：排序顺序，reverse=True降序，reverse=False升序（默认）

字符串排序是按照每个字符相应的ASCII编码进行比较。

list1 = [1,3,4,2]
list2 = ['one','two','three','four']
list3 = [2,1,'b','a']

# 数值排序
list1.sort()
print(list1) # [1, 2, 3, 4]，升序排列
list1.sort(reverse=True)
print(list1) # [4, 3, 2, 1]，降序排列

# 字符串排序
list2.sort()
print(list2) # ['four', 'one', 'three', 'two']，具体为什么这么排序，参考下面各个字母的ASCII编码大小，也就是各个字母的先后顺序
print('f:%d'% ord('f')) # f:102
print('o:%d'% ord('o')) # o:111
print('t:%d'% ord('t')) # t:116
print('h:%d'% ord('h')) # h:104
print('w:%d'% ord('w')) # w:119

# sort不支持数值和字符串混合的排序
list3.sort() # TypeError: '<' not supported between instances of 'str' and 'int'

# 给定排序键值排序
list2.sort(key=lambda x: x[0])
print(list2) # ['four', 'one', 'two', 'three']，按照首字母顺序升序排列
list2.sort(key=lambda x: x[1], reverse=True)
print(list2) # ['two', 'four', 'one', 'three']，按照第二个字母顺序降序排列
2.1.11.2 sorted函数

sorted(iterable, key=None, reverse=False) ：对可迭代对象（不仅仅是列表，而列表的sort方法只适用列表对象）进行排序

  • iterable：可迭代对象
  • key：排序键值
  • reverse：排序顺序，reverse=True降序，reverse=False升序（默认）

sorted函数和列表的sort方法在功能上几乎一样，但是更加灵活强大。而且列表的sort方法会对原列表直接做更改，而sorted函数不会，其返回修改之后的副本。

list1 = [1,3,4,2]
list2 = ['one','two','three','four']
list3 = [2,1,'b','a']

# 数值排序
print(sorted(list1)) # [1, 2, 3, 4]，升序排列
print(sorted(list1,reverse=True)) # [4, 3, 2, 1]，降序排列

# 字符串排序
print(sorted(list2)) # ['four', 'one', 'three', 'two']，具体为什么这么排序，参考下面各个字母的ASCII编码大小，也就是各个字母的先后顺序

# sort不支持数值和字符串混合的排序
sorted(list3) # TypeError: '<' not supported between instances of 'str' and 'int'

# 给定排序键值排序
print(sorted(list2,key=lambda x: x[0])) # ['four', 'one', 'two', 'three']，按照首字母顺序升序排列
print(sorted(list2,key=lambda x: x[1],reverse=True)) # ['two', 'four', 'one', 'three']，按照第二个字母顺序降序排列
2.1.11.3 reverse

参考1.10节。另外，list[::-1]也可实现类似的功能。

2.2 进阶操作

2.2.1 返回列表排序索引

list.sort()方法只是对原列表进行排序，但并不会返回排序列表的索引。熟悉matlab的朋友都知道，matlab中的sort排序函数不仅会返回排序之后的序列，还会返回其对应的索引序列，方便进一步的操作。

下面的方法展示了如何通过sorted函数，”逆向思维“得到排序列表的索引：

list1 = [1,3,2,5,6,9,8,7,4,10]

# 升序排序的索引值
sorted_index = sorted(range(len(list1)), key = lambda k: list1[k])
print(sorted_index) # [0, 2, 1, 8, 3, 4, 7, 6, 5, 9]

# 降序排序的索引值
sorted_index = sorted(range(len(list1)), key = lambda k: list1[k], reverse=True)
print(sorted_index) # [9, 5, 6, 7, 4, 3, 8, 1, 2, 0]

2.2.2

2.2.3

Reference

[1]: https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
[2]: https://m.py.cn/jishu/jichu/13609.html
[3]: https://www.runoob.com/python3/python3-att-list-max.html
大笨牛@
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python中列表相关操作/访问列表/列表更新/删除/常用的List函数方法
不问江湖
04-15 3026
列表/List 列表是一组使用方括号括起来的数据，元素中间使用逗号进行分隔,可以存放任意类型的对象，例如：list = [1, 'abc', [1, 2, 3], (1, 2, 3), {"A": "apple"}]，是一个可变对象，所以可以进行增、删、改、切片等操作； 访问列表 访问列表中的元素同字符串类似，是根据下标(索引)进行访问，索引从左向右是正索引从0开始，依次1，2，3…等类推；索引从右向左是从-1开始的，依次是-2，-3，-4…类推，切片之后取到的数据仍是一个列表。 访问元素：list[下标值
python序列类型方法
liukongxing的博客
07-11 526
要提取的下标不能超出列表范围。
Python基础三
Wh0am1的博客
05-02 325
使用list与tuplelisttalking is cheap, show me the code >>> classmate=['Michael','Wh0am1','Linux'] >>> len(classmate) 3 >>> classmate[-1] 'Linux' >>> classmate[-2] 'Wh0am1' >>> classmate[-3] 'Michael' >>
4、C/C++ 概述
Man
10-05 721
1. 面向对象的几个特征 封装性： 把对象的属性和方法结合成一个独立的系统单位，并尽可能隐藏对象的内部细节。 封装是面向对象思想描述的基础，从此程序员不再面对一个个变量和函数，而是要放眼大局，面对一个个对象来看问题。 继承性： 子类自动共享父类之间数据和方法的机制。 多态性： 在基类中定义的属性和行为(方法)被子类继承后，可以具有不同的数据类型或者表现行为(方法)等特性。 可以对不同类的对象调
Python学习小记（四）Python数据类型③列表和元组
m0_63056950的博客
04-06 1862
PythonPython的常见序列类型包括字符串、列表(list)和元组。上一篇的字符串，其实就是一种常见的序列，通过索引访问字符串内的字符程序就是序列的示范程序。序列类型支持双向索引，即若第一个元素下标为0，第二个下标为1，以此类推；或者最后一个元素下标为-1，倒数第二个元素下标为-2，以此类推。 与字符串不同的是，列表是可变的，即可在原处修改其中的内容。列表是有序可变序列，而字符串是有序不可变序列。当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有...
python列表返回重复数据的下标
09-17
首先，我们需要理解Python列表的基本操作。列表是Python中最常用的数据结构之一，它允许存储任意类型的元素，并且可以进行动态扩展和收缩。列表中的每个元素都有其唯一的索引，索引是从0开始的整数，用于访问和修改...
Python列表
12-22
Python学习之路，点击有全套Python笔记 列表的数据项不需要具有相同的类型，其中的元素之间可以没有任何关系，也可以进行嵌套。 将列表打印出来，包含方括号 list1 = [1, 2, 'hello', 'world', ['jack']] print(list...
python列表推导式操作解析
09-18
Python列表推导式是Python语言中的一个强大特性，它提供了一种简洁且高效的方式来创建新的列表。通过在一行内表达循环和条件判断，列表推导式可以极大地减少代码的复杂性和体积，使得代码更加易读。 列表推导式的...
Python列表推导式
01-20
列表推导式书写形式：list = [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件] , 记得加[ ] 多重嵌套：example = [[1,2,3],[4,5,6],[7,8,9],[10]]  list = [表达式 for 变量1 in ...
Python列表总结.pdf
03-11
Python列表总结.pdf
TypeError: set expected at most 1 arguments, got 4
热门推荐
游海东的技术专栏
05-20 2万+
1、错误描述&gt;&gt;&gt; set(1,3,4,56); Traceback (most recent call last): File "&lt;pyshell#157&gt;", line 1, in &lt;module&gt; set(1,3,4,56); TypeError: set expected at most 1 arguments, got 42...
已解决TypeError: read_csv() got an unexpected keyword argument ‘shkiprows‘
努力让自己发光，对的人才能迎着光而来
10-11 1万+
已解决（pandas读取csv文件报错）TypeError: read_csv() got an unexpected keyword argument ‘shkiprows‘
robotframework 使用 FAIL : Keyword 'public.token_userlogin' expected 2 arguments, got 0.
liubo37的博客
10-09 2428
robotframework 使用 FAIL : Keyword ‘public.token_userlogin’ expected 2 arguments, got 0. 在使用robot过程中遇到的问题记录下来，以便以后自己查阅，在使用全局变量Suite Variable时出现的报错。 可以看出我是需要传递两个参数的${phone} | ${pwd} 在Suite 设置 测试用例： 执行...
python中的列表的使用
pokendemon的博客
05-21 207
列表的合并：append，extend,+append()用于在元素后面添加数据，用于在列表的末尾添加新的对象，a={"a":1}b=[]b.append(a)b[{'a': 1}]无返回值，但是会修改原来的列表，append 只能给列表添加一个值，append可以添加一个新的列表，但是新添加的列表作为内嵌列表，TypeError: append() takes exactly one argum...
go里面报错sql: expected 0 arguments, got 1 问题的解决
程序员记事本
01-19 1万+
之前搞java比较多，用go也是用gorm,xorm这些orm框架，直接拿着sql.db对象去操作数据库比较少，一不小心就掉进一个小坑里面去了，golang操作postgres数据库可以用lib/pg驱动，写查询条件参数的时候例如 select a from b where c=? 这么写在java里面是没有问题，但是在golang里面不行，会报无效字符，针对postgres数据库写条件参数...
TypeError: append() takes exactly one argument (3 given)
Fwuyi的博客
02-27 1万+
错误的原因是：append() 函数只接受一个参数，即append(一个参数)，但是你错误的输入了三个参数，比如说 X=[1,2] X.append(1,2,3) print(X) # 报错：TypeError: append() takes exactly one argument (3 given) 1，2，3分别是3个参数，代码错误。 而当修改参数为一个元素3或者一个元素[1,2,3]，可以正确输出。 X=[1,2] X.append(3) print(X) X.append([1,2
lua table.insert报错 bad argument #2 to table (number expected, got string)
Mr_老冷的博客
06-03 6147
lua报错代码实例: local k= 'text="123sdf圣达菲s | 1232" asdf' local a = {} print(k:gsub("123","")) table.insert(a,k:gsub("123","")) text="sdf圣达菲s | 2" asdf 2 bad argument #2 to 'table' (number expected, got string) 原因在于,lua的table.insert 本来接收3个参数, table,po...
python列表换数组
最新发布
07-04
如果你有一个Python列表，可以使用`numpy.array()`函数将其转换为数组。例如： ```python import numpy as np # 假设我们有一个列表 lst = [1, 2, 3, 4, 5] # 将列表转换为numpy数组 arr = np.array(lst) print...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值