Python list 常见用法

最新推荐文章于 2023-11-10 19:46:23 发布
最新推荐文章于 2023-11-10 19:46:23 发布
阅读量639 收藏
点赞数
文章标签： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40523298/article/details/127062607
版权

测试你对Python列表知识的60个问题 通过掌握列表基础知识来压制算法问题

图片来自Pexels的Andrew Neel 我最近做了很多算法题，发现自己对列表的理解并不尽如人意。

这是我写的60个列表问题的汇编，以评估我自己的知识。

我希望你会发现它和写它对我一样有用。

问题1-10。

  1. 检查一个列表是否包含一个元素 如果一个特定的元素在一个列表中，in运算符将返回True。 
li = [1,2,3,'a','b','c']
'a' in li 
#=> True
  1. 如何同时在2个以上的列表上进行迭代 你可以压缩()列表，然后迭代zip对象。zip对象是一个图元的迭代器。

下面我们同时对3个列表进行迭代，并将数值插值为一个字符串。


name = ['Snowball', 'Chewy', 'Bubbles', 'Gruff']
animal = ['Cat', 'Dog', 'Fish', 'Goat']
age = [1, 2, 2, 6]
z = zip(name, animal, age)
z #=> <zip at 0x111081e48>
for name,animal,age in z:
    print("%s the %s is %s" % (name, animal, age))
    
#=> Snowball the Cat is 1
#=> Chewy the Dog is 2
#=> Bubbles the Fish is 2
#=> Gruff the Goat is 6
  1. 你什么时候会使用列表和字典？

列表和字典的使用情况一般略有不同，但也有一些重叠的地方。

我得出的算法问题的一般规则是，如果你能同时使用，就使用字典，因为查找的速度更快。

列表

如果你需要存储某些东西的顺序，就使用列表。

例如：数据库记录的id，按其显示的顺序。

ids = [23,1,7,9]

虽然从 python 3.7 开始，列表和字典都是有序的，但列表允许重复的值，而字典不允许重复的键。

字典

如果你想计算某个东西的出现次数，可以使用字典。比如家里有多少只宠物。

pets = {'dogs':2, 'cats':1, 'fish':5}

。 每个键在一个字典中只能存在一次。注意，键也可以是其他不可变的数据结构，如图元。例如：

{('a',1):1, ('b',2):1}

。

  1. 列表是可变的吗？

是的。请注意下面的代码，在内存中与同一标识符相关的值并没有改变。

x = [1]
print(id(x),':',x) #=> 4501046920 : [1]
x.append(5)
x.extend([6,7])
print(id(x),':',x) #=> 4501046920 : [1, 5, 6, 7]
  1. 列表必须是同质的吗？

不需要。不同类型的对象可以混合在一个列表中。

a = [1,'a',1.0,[]]
a #=> [1, 'a', 1.0, []]
  1. append和extend之间的区别是什么？

.append() 将一个对象添加到一个列表的末尾。

a = [1,2,3]
a.append(4)
a #=> [1, 2, 3, 4]

这也意味着追加一个列表将整个列表作为一个元素添加，而不是追加它的每个值。

a.append([5,6])
a #=> [1, 2, 3, 4, [5, 6]]

.extend() 将第二个列表中的每个值作为它自己的元素加入。所以用另一个列表来扩展一个列表，将它们的值结合起来。

b = [1,2,3]
b.extend([5,6])
b #=> [1, 2, 3, 5, 6]
  1. python 列表是存储值还是指针？

Python 列表本身并不存储值。它们存储指向内存中其他地方的值的指针。这允许列表是可变的。

这里我们初始化值 1 和 2，然后创建一个包括值 1 和 2 的列表。

print( id(1) ) #=> 4438537632
print( id(2) ) #=> 4438537664
a = [1,2,3]
print( id(a) ) #=> 4579953480
print( id(a[0]) ) #=> 4438537632
print( id(a[1]) ) #=> 4438537664

注意到这个列表有自己的内存地址。但是列表中的1和2与我们之前定义的1和2指向内存中的同一位置。

8. del 是做什么的？ del从一个列表中删除一个给定索引的项目。

这里我们将删除索引1的值。

a = ['w', 'x', 'y', 'z']
a #=> ['w', 'x', 'y', 'z']
del a[1]
a #=> ['w', 'y', 'z']

注意del并没有返回被删除的元素。

  1. remove和 pop之间的区别是什么？

.remove()删除一个匹配对象的第一个实例。下面我们删除第一个b。

a = ['a', 'a', 'b', 'b', 'c', 'c']
a.remove('b')
a #=> ['a', 'a', 'b', 'c', 'c']

.pop()通过索引删除一个对象。

pop和del的区别在于，pop返回被弹出的元素。这允许像堆栈一样使用一个列表。

a = ['a', 'a', 'b', 'b', 'c', 'c']
a.pop(4) #=> 'c'。
a #=> ['a', 'a', 'b', 'b', 'c']

默认情况下, 如果没有指定索引, pop会从一个列表中删除最后一个元素.

  1. 删除列表中的重复元素

如果你不关心保持列表的顺序，那么转换为集合，再转换为列表就可以实现这个目的。

li = [3, 2, 2, 1, 1, 1].
list(set(li)) #=> [1, 2, 3]

问题11-20

  1. 找到第一个匹配元素的索引

例如，你想在一个水果的列表中找到第一个 "苹果"。 使用.index()方法。

fruit = ['pear', 'orange', 'apple', 'grapefruit', 'apple', 'pear']
fruit.index('apple') #=> 2
fruit.index('pear') #=> 0
  1. 从一个列表中删除所有元素

与其创建一个新的空列表，我们不如用.clear()清除现有列表中的元素。

fruit = ['pear', 'orange', 'apple']
print( fruit )     #=> 
['pear', 'orange', 'apple']

print( id(fruit) ) #=> 
4581174216

fruit.clear()
print( fruit )     #=> []
print( id(fruit) ) #=> 4581174216

或者用del

fruit = ['pear', 'orange', 'apple']
print( fruit )     #=> ['pear', 'orange', 'apple']
print( id(fruit) ) #=> 4581166792
del fruit[:]
print( fruit )     #=> []
print( id(fruit) ) #=> 4581166792
  1. 遍历一个列表中的值和它们的索引

enumerate()在作为参数传递的列表中添加一个计数器。

下面我们对列表进行迭代，并将值和索引都传到字符串插值中。

grocery_list = ['flour','cheese','carrots']
for idx,val in enumerate(grocery_list):
    print("%s: %s" % (idx, val))
    
#=> 0: flour
#=> 1: cheese
#=> 2: carrots
  1. 如何将两个列表连接起来

+运算符将串联两个列表。

one = ['a', 'b', 'c']
two = [1, 2, 3]
one + two #=> ['a', 'b', 'c', 1, 2, 3]
  1. 如何用列表理解法操作列表中的每个元素

下面我们返回一个新的列表，每个元素都加了1。

li = [0,25,50,100]。
[i+1 for i in li] 
#=> [1, 26, 51, 101]
  1. 计算一个特定对象在列表中的出现次数

count()方法返回一个特定对象的出现次数。下面我们返回字符串 "fish "在一个叫做pets的列表中的出现次数。

pets = ['dog', 'cat', 'fish', 'fish', 'cat']
pets.count('fish')
#=> 2
  1. 如何浅层复制一个列表？

.copy()可以用来浅层复制一个列表。

下面我们创建一个round1的浅层拷贝，将其分配给一个新的名字round2，然后删除sonny chiba这个字符串。

round1 = ['chuck norris', 'bruce lee', 'sonny chiba']
round2 = round1.copy()
round2.remove('sonny chiba')
print(round1) #=> ['Chuck Norris', 'Bruce Lee', 'sonny chiba']
print(round2) #=> ['Chuck Norris', 'Bruce Lee']
  1. 为什么要创建一个列表的浅层拷贝？

在前面的例子基础上，如果我们不创建一个浅层拷贝，修改round2就会修改round1。

round1 = ['chuck norris', 'bruce lee', 'sonny chiba']
round2 = round1
round2.remove('sonny chiba')
print(round1) #=> ['Chuck Norris', 'Bruce Lee']
print(round2) #=> ['Chuck Norris', 'Bruce Lee']

如果没有浅层拷贝，round1和round2只是指向内存中同一个列表的名字。这就是为什么看起来改变一个的值会改变另一个的值。

  1. 如何深度复制一个列表？

为此我们需要导入 copy 模块，然后调用 copy.deepcopy()

下面我们创建一个列表的深度拷贝，round1称为round2，更新round2的一个值，然后打印这两个值。在这种情况下，round1不受影响。

round1 = [
    ['Arnold', 'Sylvester', 'Jean Claude'],
    ['Buttercup', 'Bubbles', 'Blossom']
]
import copy
round2 = copy.deepcopy(round1)
round2[0][0] = 'Jet Lee'
print(round1)
#=> [['Arnold', 'Sylvester', 'Jean Claude'], ['Buttercup', 'Bubbles', 'Blossom']]
print(round2)
#=> [['Jet Lee', 'Sylvester', 'Jean Claude'], ['Buttercup', 'Bubbles', 'Blossom']]

上面我们可以看到，改变round2中的嵌套数组并没有更新round1。

  1. 深拷贝和浅拷贝的区别是什么？ 在前面的例子基础上，创建一个浅层拷贝，然后修改它，会影响到原来的列表。 
round1 = [
    ['Arnold', 'Sylvester', 'Jean Claude'],
    ['Buttercup', 'Bubbles', 'Blossom']
]
import copy
round2 = round1.copy()
round2[0][0] = 'Jet Lee'
print(round1)
#=> [['Jet Lee', 'Sylvester', 'Jean Claude'], ['Buttercup', 'Bubbles', 'Blossom']]
print(round2)
#=> [['Jet Lee', 'Sylvester', 'Jean Claude'], ['Buttercup', 'Bubbles', 'Blossom']]

为什么会发生这种情况？

创建一个浅层拷贝确实在内存中创建了一个新的对象，但是它充满了对现有对象的引用，与之前的列表相同。

创建一个深层拷贝会创建原始对象的副本并指向这些新的版本。因此，新列表完全不受旧列表变化的影响，反之亦然。

问题21-30

  1. 列表和元组之间有什么区别。

元组在创建后不能被更新。添加/删除/更新一个现有的元组需要创建一个新的元组。

列表在创建后可以被修改。

元组通常代表一个对象，如从数据库加载的记录，其中的元素是不同的数据类型。

Lists一般用于存储一个特定类型的对象的有序序列（但不一定）。

两者都是序列，允许重复的值。

  1. 返回一个列表的长度 len()可以返回一个列表的长度。 
li = ['a', 'b', 'c', 'd', 'e']
len(li)
#=> 5

但是注意它计算的是顶层对象，所以一个由几个整数组成的嵌套列表只会被算作一个对象。下面，li的长度是2，而不是5。

li = [[1,2],[3,4,5]] 。
len(li)
#=> 2
  1. 列表和集合的区别是什么？

列表是有序的, 而集合不是. 这就是为什么使用set来寻找列表中的唯一值, 像

list(set([3, 3, 2, 1])) 

会改变顺序.

列表经常被用来追踪顺序，而集合则经常被用来追踪存在。

列表允许重复，但集合中的所有值根据定义是唯一的。

  1. 如何检查一个元素是否不在列表中？

为此，我们使用in运算符，但在其前面加上not。

li = [1,2,3,4] 。
5 not in li #=> True
4 not in li #=> False
  1. 用map函数将一个列表中的每个元素乘以5

map()允许在一个序列上迭代，并用另一个函数来更新每个值。 map()返回一个map对象，但我用一个列表理解来包装它，所以我们可以看到更新的值。

def multiply_5(val):
    返回 val * 5
a = [10,20,30,40,50]
[val for val in map(multiply_5, a)]。
#=> [50, 100, 150, 200, 250]
  1. 用zip函数将两个列表合并为一个图元列表

zip()将多个序列合并成一个图元的迭代器，在同一序列索引的值被合并在同一个图元中。

alphabet = ['a', 'b', 'c']
integers = [1, 2, 3]
list(zip(alphabet, integers))
  1. 在现有列表的特定索引处插入一个值 insert()方法接收一个要插入的对象和要插入的索引。 
li = ['a', 'b', 'c', 'd', 'e']
li.insert(2, 'HERE')
li #=> ['a', 'b', 'here', 'c', 'd', 'e']

注意，之前在指定索引处的元素被移到了右边，而不是被覆盖。

  1. 用 reduce 函数将一个列表中的值从第一个元素中减去 reduce() 需要从 functools 中导入。

给定一个函数，reduce 遍历一个序列并在每个元素上调用该函数。在下一个元素上调用函数时，前一个元素的输出被作为参数传递。

from functools import reduce
def subtract(a,b):
    return a - b
numbers = [100,10,5,1,2,7,5]
reduce(subtract, numbers) #=> 70

上面我们从100中减去了10、5、1、2、7和5。

  1. 用filter函数从一个列表中删除负值 filter()将从一个序列中移除该函数没有返回 True 的任何元素。

下面我们删除小于 0 的元素。

def remove_negatives(x):
    return True if x >= 0 else False
    
a = [-10, 27, 1000, -1, 0, -30]
[x for x in filter(remove_negatives, a)] 
#=> [27, 1000, 0]
  1. 将一个列表转换成一个字典，其中列表元素是键 为此我们可以使用字典的理解力。 
li = ['The', 'quick', 'brown', 
      'fox', 'was', 'quick']
d = {k:1 for k in li}
d #=> {'The': 1, 'quick': 1, 
        'brown': 1, 'fox': 1, 'was': 1}

问题31-40

  1. 用lambda函数修改一个现有的列表 让我们把之前写的map函数，用 lambda把它变成一个单行代码。 
a = [10,20,30,40,50]
list(map(lambda val:val*5, a))
#=> [50, 100, 150, 200, 250]

我可以把它作为一个map对象，直到我需要对它进行迭代，但我转换为一个列表，以显示里面的元素。

  1. 删除列表中特定索引后的元素

使用slice语法，我们可以返回一个新的列表，其中只有特定索引之前的元素。

li = [1,2,3,4,5,6,7,8,9,10,
      11,12,13,14,15,16,17,
      18,19,10］
li[:10]
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  1. 删除列表中特定索引之前的元素

slice 语法也可以返回一个新的列表，其中包含指定索引之后的值。

li = [1,2,3,4,5,6,7,8,9,10,
      11,12,13,14,15,16,17,
      18,19,10] 。
li[15:]
#=> [16, 17, 18, 19, 10]
  1. 删除一个列表中2个索引之间的元素

或者在两个索引之间。

li = [1,2,3,4,5,6,7,8,9,10,
      11,12,13,14,15,16,17,
      18,19,10] 。
li[12:17]
#=> [13, 14, 15, 16, 17]
  1. 返回2个索引之间的列表中的每一个第二元素

或者在一个特定的间隔内，在指数之前/之后/之间。

这里我们使用slice语法返回指数10和16之间的每一个第2个值。

li = [1,2,3,4,5,6,7,8,9,10,
      11,12,13,14,15,16,17,
      18,19,10] 。
li[10:16:2]
#=> [11, 13, 15]
  1. 对一个整数列表按升序排序 sort() 方法将一个列表突变为升序排列。 
li = [10,1,9,2,8,3,7,4,6,5] 。
li.sort()
li #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
  1. 对一个整数列表按降序排序

通过添加参数reverse=True，也可以用sort()进行降序排序。

li = [10,1,9,2,8,3,7,4,6,5] 。
li.sort(reverse=True)
li #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 
  1. 用列表理解法从列表中过滤偶数值

你可以在列表理解中添加条件逻辑，以过滤掉遵循特定模式的值。

这里我们过滤掉能被 2 整除的值。

li = [1,2,3,4,5,6,7,8,9,10]。
[i for i in li if i % 2 != 0]。
#=> [1, 3, 5, 7, 9]
  1. 计算一个列表中每个值的出现次数

一种选择是迭代一个列表并将计数添加到一个字典中。但是最简单的方法是从 collections 中导入 Counter 类，然后将列表传递给它。

from collections import Counter
li = ['blue', 'pink', 'green', 
      'green', 'yellow', 'pink', 'orange']
Counter(li)
#=> Counter({'blue': 1, 'pink': 2, 
            'green': 2, 'yellow': 1, 'orange': 1})
  1. 从一个列表中的每个嵌套列表中获取第一个元素

列表理解很适合在一个由其他对象组成的列表上进行迭代，并从每个嵌套对象中抓取一个元素。

li = [[1,2,3], [4,5,6], 
      [7,8,9], [10,11,12],
      [13,14,15]]
[i[0]for i in li]
#=> [1, 4, 7, 10, 13]

问题41-50

  1. 对一个列表来说，插入、查找和删除的时间复杂度是多少？

插入是O(n)复杂度，如果一个元素被插入到开头，所有其他元素必须向右移动。

通过索引查找是O(1)。但是按值查找是O(n)，因为元素需要被迭代直到找到值。

删除是O(n)。如果一个元素在开始时被删除，所有其他的元素必须向左移动。

  1. 将一个列表中的元素合并成一个字符串。 这可以用 join() 函数来完成。 
li = ['The','quick','brown', 
      'fox', 'jumped', 'over', 
      'the', 'lazy', 'dog']
' '.join(li)
#=> 
'The quick brown fox jumped over the lazy dog'

  1. 列表乘以一个整数有什么影响？

将一个列表乘以一个整数被称为多重连接，其影响与将一个列表与它本身连接n次是一样的。

下面我们将一个列表乘以5。

['a','b'] * 5
#=> 
['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']

这与以下情况相同

['a','b'] + ['a','b'] + ['a','b'] + ['a','b]] 
#=> ['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
  1. 使用 "any "函数，如果列表中的任何值都能被2整除，则返回True

我们可以将any()与列表理解结合起来，如果返回的列表中的任何值评估为 True，则返回 True。

下面的第一个列表理解返回 True，因为该列表中有一个 2，是可以被 2 整除的。


li1 = [1,2,3]。
li2 = [1,3]
any(i % 2 == 0 for i in li1) #=> True
any(i % 2 == 0 for i in li2) #=> False

  1. 使用 "all "函数，如果一个列表中的所有值都是负数，则返回 "真 与 any()函数类似, all()也可以与列表理解一起使用, 只在返回的列表中的所有值都是True时返回True。 
li1 = [2,3,4].
li2 = [2,4]
all(i % 2 == 0 for i in li1) #=> False
all(i % 2 == 0 for i in li2) #=> True
  1. 你能对一个含有 "None "的列表进行排序吗?

你不能对含有 "无 "的列表进行排序，因为比较运算符(sort()使用的)不能将一个整数与 "无 "进行比较。

li = [10,1,9,2,8,3,7,4,6,None] 。
li.sort()
li #=> TypeError: 'NoneType'和'int'的实例之间不支持'<'
  1. 列表构造函数会从一个现有的列表中创建什么样的副本?

list 构造函数为传入的 list 创建一个浅层拷贝。也就是说，这比使用 .copy() 更不符合 pythonic。

li1 = ['a','b'] 。
li2 = list(li1)
li2.append('c')
print(li1) #=> ['a', 'b']
print(li2) #=> ['a', 'b', 'c']
  1. 反转一个列表的顺序

可以用reverse()方法将一个列表突变为反向顺序。

li = [1,2,3,4,5,6,7,8,9,10] 。
li.reverse()
li #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 

注意，这是在保持原对象的id()地址不变，改变顺序，而不是返回一个新对象。

  1. reverse和reversed之间的区别是什么?

reverse()将列表原地反转，改变原变量列表的顺序！小心 reversed()返回列表的一个反向顺序的可迭代对象。


li = [1,2,3,4,5,6,7,8,9,10] 。
list(reversed(li))
#=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
  1. sort和sorted之间的区别是什么？

sort()在原地修改列表。 sorted()返回一个相反顺序的新列表。

li = [10,1,9,2,8,3,7,4,6,5]
li.sort()
li #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
li = [10,1,9,2,8,3,7,4,6,5] 。
sorted(li) #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

问题51-60

  1. 返回一个列表中的最小值 min()函数返回一个列表中的最小值。 
li = [10,1,9,2,8,3,7,4,6,5] 
min(li)
#=> 1
  1. 返回列表中的最大值

max()函数返回一个列表中的最大值。

li = [10,1,9,2,8,3,7,4,6,5] 
max(li)
#=> 10

  1. 返回一个列表中的数值之和

sum()函数返回一个列表中所有数值的总和。

li = [10,1,9,2,8,3,7,4,6,5] 
sum(li)
#=> 55
  1. 将一个列表作为一个堆栈

你可以使用append()和pop()来把一个列表当作一个堆栈。堆栈的功能是按后进先出（last in first out）

stack = []
stack.append('Jess')
stack.append('Todd')
stack.append('Yuan')
print(stack) #=> ['Jess', 'Todd', ' Yuan']
print(stack.pop()) #=> Yuan
print(stack) #=> ['Jess', 'Todd']

堆栈的一个好处是，可以在O(1)时间内添加和删除元素，因为列表不需要被迭代。

  1. 寻找2个列表的交集

我们可以通过利用带有set()来实现这个目的。

li1 = [1,2,3] 
li2 = [2,3,4]
set(li1) & set(li2)
#=> {2, 3}

  1. 找出一个集合和另一个集合的区别

我们不能-减去列表，但是我们可以减去集合。

li1 = [1,2,3] 。
li2 = [2,3,4]。
set(li1) - set(li2)
#=> {1}
set(li2) - set(li1)
#=> {4}
  1. 用列表理解法平坦一个列表

与 Ruby 不同，Python3 没有一个明确的 flatten 函数。但是我们可以使用 list comprehension 来平坦一个列表的列表。

li = [[1,2,3],[4,5,6]] 
[i for x in li for i in x]
#=> [1, 2, 3, 4, 5, 6]

  1. 生成一个2个值之间的每个整数的列表

我们可以在2个值之间创建一个范围，然后将其转换为一个列表。

list(range(5,10))
#=> [5, 6, 7, 8, 9]

  1. 将 2 个列表合并成一个字典

使用 zip() 和 list() 构造函数，我们可以将 2 个列表合并成一个字典，其中一个列表成为键，另一个列表成为值。

name = ['Snowball', 'Chewy', 'Bubbles', 'Gruff']
animal = ['Cat', 'Dog', 'Fish', 'Goat']
dict(zip(name, animal))

  1. 使用slice语法反转列表的顺序

虽然我们可以用 reverse() 和 reversed() 来反转一个列表，但也可以用 slice 语法来完成。

这将通过从头到尾遍历列表返回一个新的列表。


li = ['a','b',3,4] 。
li[::-1]
#=> [4, 3, 'b', 'a']

结论 在完成这些工作后，我觉得自己更有能力解决算法问题，而不必再猜测具体的列表方法。

消除不断的搜索可以为更高层次的思考释放能量，比如让一个函数做它应该做的事，并降低函数的复杂性。

再次，我希望你也觉得这很有用。

本文由 mdnice 多平台发布

丁丁猫 Codeye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第34讲：Python中集合对象的概念以及基本使用
江晓龙的博客
04-11 1万+
前面不是说创建集合时，集合中的参数不能是列表吗，为什么又用列表了，注意这里并不是将列表作为集合中的元素，而是要把集合中的元素放在列表内，然后通过set函数将其创建成集合。除了列表、元组和字典外，集合也是Python语言提供的内置数据结构，可以抽象的将集合理解为是没有存储Value的字典，在集合中只有Key。当定义集合时，集合中有重复的元素，重复的元素也会被去掉，因为集合中不允许有重复的值。字符串是字符的集合，会将传入的字符串按照字符为元素，创建出集合。集合中的元素不能是列表，集合中的元素也不能是集合。
问题之Python的List可变对象
xu_yushu的博客
05-04 1234
关于Python的List可变对象的问题与坑，希望对你的学习有所帮助，尽量少踏入坑。
python的List对象
你呢的博客
02-12 2208
**PyListObject对象** ```c typedef struct { PyObject_VAR_HEAD PyObject **ob_itemc; Py_ssize_t allocated; } PyListObject; ``` ob_itemc是指向元素列表的一个指针，在PyListObject对象中，有一个allocated字段，那么这个字段与PyObject_VAR_HEAD中的ob_size字段有什么关系呢？实际上，allocated指的是当前对象可容纳的元素的
python基本数据类型--列表（list）
爆笑蛙的博客
06-15 1万+
本文详细介绍了列表的定义，列表的索引切片、拼接方式、重复操作、删除元素、增加元素、统计元素个数、查看元素索引值、列表的排序、列表大小的比较方式、列表的成员区分、身份运算等。列表是用[]作为边界逗号作为分隔符，可容纳所有对象的数据类型，如：[]，[1, "a", 5, 'cd']等等，是可迭代的数据类型，可以被修改。在一个列表中我们可以放入任何的python对象，包括列表本身。
python list存储对象_《python解释器源码剖析》第4章--python中的list对象
weixin_39832448的博客
12-07 1160
4.0 序python中的list对象，底层对应的则是PyListObject。如果你熟悉C++，那么会很容易和C++中的list联系起来。但实际上，这个C++中的list大相径庭，反而和STL中的vector比较类似4.1 PyListObject对象我们知道python里面的list对象是支持对元素进行增删改查等操作的，list对象里面存储的，底层无一例外都是PyObject * 指针。所以实...
Python中列表元素增加的三种方式
热门推荐
m0_69919595的博客
05-11 2万+
1.使用append函数向列表中增加元素，把元素增加到列表的末尾，可以增加任意类型的元素。 语法：list1.append(新增的列表元素) 示例： 2.使用insert函数向列表中新增元素，在指定的列表的索引位置的左边进行插入元素 语法：list1.insert(索引,新增的元素) ...
Python list操作用法总结
12-23
本文实例讲述了Python list操作用法。...Python list常见操作如下： 创建列表 复制代码 代码如下:sample_list = [‘a’,1,(‘a’,’b’)] Python 列表操作 复制代码 代码如下:sample_list = [‘a’,’b’,0,1,3] 得
python同时遍历两个list用法说明
12-20
标题所提到的"python同时遍历两个list用法说明"主要聚焦于使用`zip`函数来实现这个目的。`zip`函数是Python中一个非常实用的内置函数，它可以将多个可迭代对象（如列表）打包成一个个元组，然后返回这些元组组成的...
Python文件读写常见用法总结
09-19
本篇文章将总结Python文件读写的一些常见用法，帮助开发者更好地理解和使用这些功能。 1. **读取文件** - **打开文件**：在Python中，使用`open()`函数打开文件，通常需要指定文件名和模式。例如，`f=open('...
Python常见的pandas用法demo示例
09-19
本篇文章将详细介绍Python中pandas的基本用法，包括创建、操作和分析数据。 首先，我们导入pandas库，并通过创建Series来熟悉基本操作。Series可以理解为带索引的数组，如下所示： ```python import numpy as np ...
python迭代器常见用法实例分析
01-02
本文实例讲述了python迭代器常见用法。分享给大家供大家参考，具体如下： 迭代器 迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被...
python列表list添加元素的三种方法
weixin_47378963的博客
03-28 1778
这里介绍的python列表添加元素主要是在列表的末尾添加元素，与此同时，介绍三种添加元素的方法，分别是__add__()魔法方法（magic method）、append()方法，以及extend()方法来添加。下面将通过实例对此一一进行详细的介绍。
python List添加元素的4种方法
matinal 當冬夜漸暖 。公众号：matinal
07-27 5878
而将两个list相加，需要创建新的list对象，从而需要消耗额外的内存， 特别是当list较大时，尽量不要使用“+”来添加list，而应该尽可能使用List的append()方法。extend()相当于是将list B 连接到list A上。【1】 append() 追加单个元素到List的尾部，只接受一个参数，参数可以是任何数据类型，被追加的元素在List中保持着原结构类型。【3】 insert(i,val) 将一个元素val插入到列表的i索引处，第一个参数是索引，即插入的位置，第二个参数是插入的元素。
Python 中list使用详解
m0_50816276的博客
04-20 3331
append()：向列表末尾添加一个元素。 extend()：将一个列表中的元素追加到另一个列表的末尾。 insert()：向列表中的指定位置插入一个元素。 remove()：删除列表中第一个匹配指定元素的元素。 pop()：删除并返回列表中指定位置的元素。 index()：返回列表中第一个匹配指定元素的索引。 count()：返回列表中指定元素的数量。 sort()：原地对列表进行排序。 reverse()：原地反转列表中的元素顺序。 copy()：返回一个新的列表，包含原始列表中的所有元素。
Python存储对象（集合、元组，字典）
qq_33473340的博客
03-07 2338
list集合[arg,arg…]，有序，可变，相当于数组，可用-1取最后元素以此类推-2 -3 方法：1、list.append(arg) arg是添加到集合末尾的元素            2、list.inser(arg1, arg2) arg1为位置，arg2为元素   ...
Python数据结构： 列表（List）详解
Snailandfish的专栏
11-10 1万+
在Python中，列表（List）是一种有序、可变的数据类型，被广泛用于存储和处理多个元素。列表是一种容器，可以包含任意数据类型的元素，包括数字字符串列表字典等。本文将深入讨论列表的各个方面，包括基本语法、常见操作，以及实际应用场景。将覆盖列表的创建访问修改列表推导式和嵌套列表推导式等关键内容。
列表 - Python对象
qq_33596591的博客
05-04 2299
列表(list)，可以简单视之为双向连结串行，以线性列的方式管理物件集合。当然，在Python中，列表是可以含有重复元素的，python的列表与c语言中的数组比较相似。 在Python中，列表可以同时存储多个元素，而程序也可以对这些数据进行整体操作。 1.列表的创建 列表主要有两种创建方式： 方式一：变量名 = [列表元素]，例如： lst = [1, 2, 'a', 1.4] 方式二：变量名 = list([列表元素])，例如： lst = list([1, 2, 'a', 4])
【知识学习】Python：列表-存储多个对象的引用
快乐小狗的成长站~
07-07 1508
python学习笔记：基础语法知识（列表）
python list 用法
最新发布
03-15
Python中的列表（list）是一种有序、可变的数据类型，可以存储多个元素。以下是Python列表的常见用法： 1. 创建列表： 可以使用方括号 [] 或者 list() 函数来创建一个空列表，也可以在创建时初始化元素。例如： ``` empty_list = [] num_list = [1, 2, 3, 4, 5] ``` 2. 访问列表元素： 可以使用索引来访问列表中的元素，索引从0开始。例如： ``` print(num_list[0]) # 输出：1 ``` 3. 修改列表元素： 列表是可变的，可以通过索引来修改列表中的元素。例如： ``` num_list[0] = 10 print(num_list) # 输出：[10, 2, 3, 4, 5] ``` 4. 列表操作： - 添加元素：使用 append() 方法在列表末尾添加元素，使用 insert() 方法在指定位置插入元素。 - 删除元素：使用 remove() 方法根据值删除指定元素，使用 del 关键字根据索引删除元素。 - 切片操作：可以使用切片操作符（:）获取列表的子集。 - 运算符操作：可以使用 + 运算符连接两个列表，使用 * 运算符重复列表。 5. 列表方法： 列表对象还提供了一些有用的方法，如 count()、sort()、reverse() 等，可以对列表进行统计、排序和反转等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值