Explication détaillée de l'utilisation des listes et des tuples dans l'apprentissage Python

Cet article vous apporte des connaissances pertinentes sur Python, qui présente principalement l'explication détaillée de l'utilisation des listes et des tuples, y compris la syntaxe de déclaration des listes, la lecture des listes, les opérations de liste, la connaissance de base des éléments et Jetons un coup d'œil à l'opération et d'autres contenus, j'espère que cela sera utile à tout le monde.

【Recommandation associée : Tutoriel vidéo Python3】

Introduction aux listes et aux tuples

Si vous recherchez le meilleur type de données dans le langage Python, c'est sans aucun doute une liste. Si vous souhaitez en recommander un. , puis je choisis les tuples. Dans ce blog, nous nous concentrerons sur les listes qui peuvent être considérées comme des listes qui ne peuvent pas être modifiées, alors en cadeau apprenez-le.

List est une structure de données très flexible qui peut compenser de nombreuses lacunes du type de chaîne précédent.

Avant l'apprentissage formel, vous devez vous souvenir de deux mots anglais, list et tuple.

Points clés pour l'apprentissage des listes

Premier coup d'œil à la définition de la liste :

Une liste est une séquence de variables et un conteneur qui peut stocker n'importe quel type de données ([]) sont utilisés pour. indiquez le début et la fin, chaque élément interne est séparé par des virgules anglaises (, ). Chaque élément peut être appelé un projet, et chaque élément a un index, également appelé indice. []）表示开始和结束，内部各元素使用英文逗号（,）分隔，每个元素都可称为项目，并且每个元素都有一个索引，也被称为下标。

列表的声明语法

声明一个列表，可以参考下述几种格式。

使用空中括号 [] 声明一个空列表

my_list = []
print(my_list)

声明包含一个元素的列表

my_list = [1]
print(my_list)

声明包含多个元素的列表

my_list = [1,2]
print(my_list)

声明包含多个不同数据类型元素的列表

my_list = [1,'a',True]
print(my_list)

声明一个列表中包含列表

my_list = [1,['a'],[True,1,1]]
print(my_list)

列表的读取

读取列表中最重要的概念是下标，也叫做位置或者索引。下标从 0 开始计数，即列表内第一项元素的索引是 0，例如下述代码，读取数字 2。

my_list = [1,2,3,4,5]
print(my_list[1]) # 数字2所在的下标为1

列表操作

列表是一个动态容器，其支持对其元素的增加，删除，修改，查询，合并等操作，用到的都是字典对象的方法，基本操作的方法名如下所示：

• append()：末尾追加元素；
• extend()：末尾追加列表，也可以理解为两个列表合并；
• insert()：在指定位置插入元素；
• copy()：列表复制；
• clear()：清空列表；
• count()：统计列表指定元素个数；
• pop()：删除并返回指定下标对应的元素；
• remove()：删除列表中指定元素；
• index()：获取指定元素的下标；
• reverse()：反转元素；
• sort()：对列表元素进行排序。

列表元素添加方法

从上述清单中，可以查看到列表追加元素，有两种办法可以实现，其一是使用 append() 方法，其二是使用 insert() 方法，示例代码如下所示：

my_list = [1,2,3,4,5]
my_list.append(888)
my_list.insert(1,666)
print(my_list)

对比一下上述两个方法的差异，可以看到 append() 仅能在里列表末尾追加元素，而 insert() 方法可以在任意位置插入元素，即 insert() 方法的第一个参数为索引，表示插入位置。

列表元素查找方法

在列表中查找某一元素，使用 index() 方法实现，该方法的语法格式如下所示：

my_list.index(value,[start[,stop]])

其中 my_list 是待查找目标列表，value 表示待查找的值，start 和 stop 为可选参数，表示开始查找的索引值和结束查找的索引值，该方法当查找到元素后，会返回第一个找到的元素索引位置，例如下述代码，会返回 3。

my_list = [1,2,3,4,5]
ret = my_list.index(4)
print(ret)

如果该方法没有在目标列表中找到元素，会报错，错误类型为 ValueError。

除 index() 方法外，列表的读取其实也是元素查找方式，例如读取下标 2 的元素，代码如下：

my_list = [1,2,3,4,5]
ret = my_list[2]
print(ret)

还可以使用成员运算符 in，对列表进行判断，关于成员操作符的更多知识，后期总结运算符的时候，会详细说明。以下代码会返回 True，即表示数字 2 在列表中。

my_list = [1,2,3,4,5]
ret = 2 in my_list
print(ret)

在列表中还有一个重要知识点，即列表切片，学习该知识点需要先牢牢掌握列表按索引读取相关语法，切片的语法格式如下：

my_list = [1,2,3,4,5]
ret = my_list[1:3:2]
print(ret)

可以看到上述第二行代码，在原列表读取的规则之上，格式变为了 [1:3:2]

Syntaxe de déclaration de liste

Pour déclarer une liste, vous pouvez vous référer aux formats suivants. 🎜🎜🎜Utilisez des crochets aériens [] pour déclarer une liste vide🎜🎜

my_list[起始索引:结束索引:步长]

🎜🎜Déclarez une liste contenant un élément🎜🎜

# 缺省结束索引，默认获取到列表结尾元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:]
print(ret) # 输出 [2, 3, 4, 5, 6, 7, 8, 9, 10]

# 缺少步长，默认按照索引+1解决，同时不包含结束索引代表的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:5]
print(ret) # 输出 [2, 3, 4, 5]

# 步长设置为2，表示索引每次+2
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:6:2]
print(ret) # 输出 [2, 4, 6]

🎜🎜Déclarez une liste contenant plusieurs éléments🎜🎜

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
print(my_list)

🎜🎜Déclarez une liste contenant plusieurs éléments de différents types de données 🎜🎜

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
my_list.clear() # 列表清空
print(my_list)

🎜🎜Déclarer qu'une liste contient une liste🎜🎜

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.pop()
print(my_list) # 删除最后一项
print(ret) # 返回被删除的元素

Lecture d'une liste

🎜Le concept le plus important dans la lecture d'une liste est l'indice, également appelé position ou index. Les indices commencent à compter à partir de 0, c'est-à-dire que l'index du premier élément de la liste est 0. Par exemple, le code suivant lit le chiffre 2. 🎜

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.remove(5)
print(my_list)
print(ret)

Opérations de liste

🎜Une liste est un conteneur dynamique qui prend en charge des opérations telles que l'ajout, la suppression, la modification, l'interrogation et la fusion de ses éléments. Toutes les méthodes utilisées sont des méthodes d'objet de dictionnaire et des méthodes d'opération de base. sont les suivants : 🎜

• append() : Ajouter des éléments à la fin
• extend() : Ajouter une liste à la fin ; la fin, également Cela peut être compris comme la fusion de deux listes ;
• insert() : Insérer un élément à la position spécifiée
• copier ; () : copie de la liste ;
• clear() : effacer la liste ;
• count() : compter le nombre d'éléments spécifiés dans la liste ;
• pop() : Supprimer et 🎜retourner🎜l'élément correspondant à l'indice spécifié
• remove() : Supprimer de la liste Spécifier l'élément ;
• index() : Récupère l'index de l'élément spécifié
• reverse() : Inverser l'élément ;
• sort() : Trier les éléments de la liste.

🎜🎜Méthode d'ajout d'éléments de liste🎜🎜🎜À partir de la liste ci-dessus, vous pouvez voir que l'ajout d'éléments à la liste peut être effectué de deux manières. La première consiste à utiliser append()<.> Méthode, la seconde consiste à utiliser la méthode <code>insert(), l'exemple de code est le suivant : 🎜

# 删除索引位置为5的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del(my_list[5])
print(my_list)


# 删除整个列表对象
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del my_list
print(my_list)

🎜En comparant les différences entre les deux méthodes ci-dessus, vous pouvez voir que append () seuls les éléments peuvent être ajoutés à la fin de la liste, et la méthode insert() peut insérer des éléments à n'importe quelle position, c'est-à-dire le premier paramètre de insert () est l'index, indiquant la position d'insertion. 🎜🎜🎜Méthode de recherche d'élément de liste🎜🎜🎜Pour rechercher un élément dans la liste, utilisez la méthode index() Le format de syntaxe de cette méthode est le suivant : 🎜

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list1.extend([666,777,888])
print(my_list1)

🎜where my_list. est une liste de cibles à rechercher, value représente la valeur à rechercher, start et stop sont des paramètres facultatifs, indiquant la valeur de l'index pour commencer la recherche et la valeur de l'index à laquelle la recherche se termine. Lorsqu'un élément est trouvé, cette méthode renverra la position d'index du premier élément trouvé. Par exemple, le code suivant renverra 3code>. 🎜

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list = my_list1 + my_list2
print(my_list)

🎜Si cette méthode ne trouve pas d'élément dans la liste cible, une erreur sera signalée avec le type d'erreur ValueError. 🎜🎜En plus de la méthode index(), la lecture d'une liste est en fait une méthode de recherche d'éléments. Par exemple, pour lire l'élément d'indice 2, le code est le suivant : 🎜

my_list = [4,1,2,6,7,3,8,12,10]
my_list.sort()
print(my_list)

🎜You. peut également utiliser l'opérateur membre dans, pour juger la liste, plus de connaissances sur les opérateurs membres seront expliquées en détail plus tard lorsque les opérateurs seront résumés. Le code suivant renvoie True, ce qui signifie que le chiffre 2 est dans la liste. 🎜

my_list.sort(key=None,reverse=False)

🎜Il y a un autre point de connaissance important dans la liste, à savoir le découpage de liste. Pour apprendre ce point de connaissance, vous devez bien maîtriser la syntaxe liée à la lecture de la liste par index. Le format syntaxique du découpage est le suivant : 🎜

my_list = ['ABC','CDS','Juejin','YUE']
my_list.sort(key=str.lower)
print(my_list)

🎜Vous pouvez voir la deuxième ligne au-dessus du Code, basé sur les règles de lecture de la liste originale, le format devient [1:3:2], et la description de la syntaxe chinoise est la suivante : 🎜

my_list[起始索引:结束索引:步长]

使用切片的时候，英文冒号不能缺少，起始索引为必选项，结束索引和步长为可选项。

如果理解困难，最好的办法就是反复用代码校验。

# 缺省结束索引，默认获取到列表结尾元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:]
print(ret) # 输出 [2, 3, 4, 5, 6, 7, 8, 9, 10]

# 缺少步长，默认按照索引+1解决，同时不包含结束索引代表的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:5]
print(ret) # 输出 [2, 3, 4, 5]

# 步长设置为2，表示索引每次+2
my_list = [1,2,3,4,5,6,7,8,9,10]
ret = my_list[1:6:2]
print(ret) # 输出 [2, 4, 6]

上述代码如何理解已经在注释中进行说明，重点要掌握的切片知识点整理如下：

一首打油诗送给大家~

切片不能丢冒号 结束步长可不要 默认索引都加一 左闭右开要牢记

列表元素的修改和删除

前文已经掌握了列表的读取，将读取到的元素重新赋值就是列表的修改，例如下述代码。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
print(my_list)

列表元素删除 在 Python 中，提出了多种列表元素删除的方式，本小节学习三个列表元素删除的方法，即 clear()，pop()，remove()，除此之外还可以使用 del() 函数对列表元素进行删除。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
my_list.clear() # 列表清空
print(my_list)

使用 pop() 方法删除列表元素，默认从尾部删除，并返回被删除的元素。

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.pop()
print(my_list) # 删除最后一项
print(ret) # 返回被删除的元素

pop() 方法中可以传递一个 index 值，该值表示下标值，即删除指定位置的元素，与之对应的是 remove() 方法的参数，该值表示待删除的目标元素，例如在列表中删除元素 5，使用的代码如下：

my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
ret = my_list.remove(5)
print(my_list)
print(ret)

测试之后，可以发现 remove() 方法无返回值，并且该方法只删除第一个匹配到的元素，也就是当列表中有多个目标元素时，只有最先匹配到的元素被删除。

del() 函数可以删除列表中指定元素，也可以直接删除列表对象，代码如下：

# 删除索引位置为5的元素
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del(my_list[5])
print(my_list)


# 删除整个列表对象
my_list = [1,2,3,4,5,6,7,8,9,10]
my_list[1] = 666
del my_list
print(my_list)

列表元素合并

使用 extend() 方法可以将列表进行合并：

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list1.extend([666,777,888])
print(my_list1)

注意 extend() 方法不会生成新的列表。

列表合并也可以使用加号（+） 实现，该语法会产生一个新的列表。

my_list1 = [1,2,3]
my_list2 = [666,777,888]
my_list = my_list1 + my_list2
print(my_list)

列表元素顺序变化

列表排序用到的方法是 sort()，该方法默认按照 ASCII 进行增序或者减序排列，测试代码如下所示：

my_list = [4,1,2,6,7,3,8,12,10]
my_list.sort()
print(my_list)

在 sort() 方法中也有 2 个参数，格式如下：

my_list.sort(key=None,reverse=False)

参数 key 为可选参数，可以传入一个函数名，该函数会作用与列表中的每一项元素，例如将列表中每一项元素都转换为小写字母。

my_list = ['ABC','CDS','Juejin','YUE']
my_list.sort(key=str.lower)
print(my_list)

sort() 方法会对原列表进行排序，如果想生成一个新列表，可以使用 sorted() 函数，代码如下：

my_list = ['ABC','CDS','Juejin','YUE']
ret = sorted(my_list)
print(ret)

除此之外，还可以使用 reverse() 方法。

my_list = ['ABC','CDS','Juejin','YUE']
my_list.reverse()
print(my_list)

元组学习要点

元组定义与列表基本一致，只需要做好如下区分即可。

• 元组不能对其包含的元素进行修改，即元组不可变；
• 元组用小括号（()）表示。

再次进行简单总结：

元组是不可变序列，也是可以包含任意数据类型的容器，用小括号（()）表示，元素之间用逗号（,）分隔 。一定要注意的就是不可变序列，不可变的含义是不能对元组进行增加，修改，删除，位置变换等操作。

元组基本知识

声明一个元组

my_tuple = ()
print(my_tuple)
print(type(my_tuple))

声明一个只包含 1 个值的元组，要求必须带一个逗号，否则会按照整数处理。

my_tuple = (1,)
print(my_tuple)
print(type(my_tuple))

声明包含多个值的元组：

my_tuple = (1,2,3,4,5,6,[1])
print(my_tuple)
print(type(my_tuple))

元组的基本操作

由于元组对象的方法使用与列表一致，接下来仅对元组进行罗列。

• count()：统计元组中元素个数；
• index()：返回指定元素的下标。

其余可作用于元组的内置函数如下所示：

• len()：获取元组元素个数；
• max()：返回元组中最大值；
• min()：返回最小值；
• tuple()：将列表转换为元组；
• type()：返回对象类型；
• del()：删除整个元组对象，注意不能删除元组内元素；
• sum()：求和。

【相关推荐：Python3视频教程 】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!