Quelles séquences sont des listes, des tuples et des chaînes en Python ?

Les listes, les tuples et les chaînes sont des séquences ordonnées de Python ; les listes sont des objets mutables, et les tuples et les chaînes sont des objets immuables. Chaque élément de la séquence se voit attribuer un numéro, qui est sa position, ou index, le premier index étant 0, le deuxième index étant 1, et ainsi de suite.

La séquence est la structure de données la plus basique en Python. Chaque élément de la séquence se voit attribuer un numéro : sa position, ou index, le premier index étant 0, le deuxième index étant 1, et ainsi de suite.

Les opérations qui peuvent être effectuées sur des séquences incluent l'indexation, le découpage, l'ajout, la multiplication et la vérification des membres. De plus, Python dispose de méthodes intégrées pour déterminer la longueur d'une séquence et déterminer les éléments les plus grands et les plus petits.

Les listes, les tuples et les chaînes sont des séquences ordonnées en Python ; les listes sont des objets mutables, tandis que les tuples et les chaînes sont des objets immuables.

Liste

Une liste est une séquence ordonnée contenant 0 ou plusieurs références d'objet, prenant en charge le même partitionnement et les mêmes étapes que les chaînes et la grammaire de distance. Contrairement aux chaînes et aux tuples, les listes sont mutables, nous pouvons donc supprimer ou remplacer des éléments de la liste, insérer, remplacer ou supprimer des tranches dans la liste.

Le type de données list peut être appelé en tant que fonction, list() - l'appel sans paramètres renverra une liste vide ; lors de la prise d'un paramètre de liste, une copie superficielle du paramètre sera renvoyée pour tout autre ; paramètres, puis tente de convertir l'objet donné en liste. La valeur de la fonction accepte un paramètre. Des listes peuvent également être créées sans utiliser la fonction list(), des listes vides peuvent être créées à l'aide de crochets vides et des listes contenant un ou plusieurs éléments peuvent être créées à l'aide d'une séquence d'éléments de données séparés par des virgules (entre []).

Méthodes fournies par les listes :

Tout type de données itérable (liste, tuple, etc.) peut être divisé à l'aide de l'opérateur de division de séquence. À l'heure actuelle : * . Lorsqu'il est utilisé pour attribuer deux variables ou plus à gauche de l'opérateur, dont l'une est introduite par *, l'élément de données sera affecté à cette variable et tous les éléments de données restants seront affectés à la variable marquée d'un astérisque, donnée ci-dessous. Quelques exemples :

Lorsque vous utilisez l'opérateur de fractionnement de séquence de cette manière, l'expression *rest et les expressions similaires sont appelées expressions avec astérisque.

Python a également un concept connexe : les paramètres marqués d'un astérisque.

La recherche scientifique effectue un traitement itératif sur les éléments de données de la liste. Le format de syntaxe utilisé est celui de l'élément dans L :. Si vous devez modifier les éléments de données dans la liste, la méthode habituelle à utiliser est la suivante :

for i in range(len(L)):
L[i] = process(L[i])

Puisque la liste prend en charge le partage, dans plusieurs cas, la même fonction peut être accomplie en utilisant le partage ou une méthode de liste. . Par exemple : étant donné la liste woods=['Cedar','If','Fir'], nous pouvons étendre la liste des deux manières suivantes :

woods+=['Kauri','Larch']    | woods.extend(['Kauri','Larch'])

Pour les deux méthodes ci-dessus, les résultats sont les deux listes ['Cèdre', 'If', 'Sapin', 'Kauri', 'Mélèze'].

À l'aide de la méthode list.append(), un seul élément de données peut être ajouté à la fin de la liste. Les éléments de données peuvent être insérés dans la liste à n'importe quelle position d'index à l'aide de la méthode list.insert() (ou en les affectant à une tranche de longueur 0). Par exemple, étant donné la liste woods=['Cedar','If','Fir','Spruce'], nous pouvons insérer un nouvel élément de données à la position d'index 2 (c'est-à-dire en tant que troisième élément de la liste), Les deux méthodes suivantes peuvent être mises en œuvre :

woods[2:2] = ['Pine'] |  woods.insert(2,'Pine')

Les résultats obtenus par les deux méthodes ci-dessus sont des listes ['Cèdre','If','Pine','Sapin','Épicéa'].

En attribuant une valeur à l'objet à une position d'index spécifique, un seul élément de données dans la liste peut être remplacé, par exemple, woods[2]='Redwood'. En attribuant un itérable à un fragment, vous pouvez remplacer le fragment entier, par exemple, woods[1:3]=['Spruce','Sugi','Rimu'], et les itérables du fragment ne doivent pas nécessairement être égaux. longueur. Dans tous ces cas, les éléments de données du fragment sont supprimés et les éléments de données de l'itérable sont insérés. Si l'itérable contient moins d'éléments que le fragment à remplacer, cette opération rend la catégorie plus courte, sinon la liste devient. L'exemple suivant :

Pour les listes complexes, vous pouvez utiliser une boucle for...in pour les créer. Par exemple, en supposant que vous deviez générer une liste d'années bissextiles. dans un intervalle de temps donné, vous pouvez utiliser la déclaration suivante :

 leaps = []
 for year in range(1900,1940):
  if (year%4 == 0 and year %100 !=0) or (year % 400 ==0):
    leaps.append(year)

Deux expressions :

expression for item in iterable
    expression for item in  iterable if condition

Tuple (tuple)

元组是个有序的序列，其中包含0个或多个对象引用。元组支持与字符串一样的分片与步距的语法，这使得从元组中提取数据项比较容易。元组也是固定的，不能替换或删除其中包含的任意数据项。如果需要修改有序序列，我们应该使用类别而非元组。如果要对元组进行修改，可以使用list()转换函数将其转换为列表，之后在产生的列表之上进行适当修改。

tuple数据类型可以作为一个函数进行调用，tuple()---不指定参数时将返回一个空元组，使用tuple作为参数时将返回该参数的浅拷贝，对其他任意参数，将尝试把给定的对象转换为tuple类型。该函数最多只能接受一个参数。元组也可以使用tuple()函数创建，空元组是使用空圆括号()创建的，包含一个或多个项的元组则可以使用逗号分隔进行创建。

元组只提供了两种方法：t.count(x)，返回对象x在元组中出现的次数；t.index(x),返回对象在元组t中出现的最左边位置。

元组可以使用操作符+（连接）、*（赋值）与 []（分片），要可以使用in 与not in 来测试成员关系。

下面给出几个分片实例：

上面这些处理过程对字符串、列表以及人员其他序列类型都是一样的

要构成一个亿元组，逗号是必须的，这里red字符串地方我们必须同时使用逗号与圆括号。

      1.1 命名的元组

       命名的元组与普通元组一样，有相同的表现特征，其添加的功能就是可以根据名称引用元组中的项，就像根据索引位置一样，这一功能使我们可以创建数据项的聚集。

       collections 模块提供了 namedtuple()函数，该函数用于创建自定义的元组数据类型，例如：

  collections.namedtuple()的第一个参数是想要创建的自定义元组数据类型的名称，第二个参数是一个字符串，其中包含使用空格分割的名称，每个名称代表该元组数据类型的一项。该函数返回一个自定义的类（数据类型），用于创建命名的元组。因此，这一情况下，我们将sale与任何其他python类一样看待，并创建类型为sale的对象，如：

这里我们厂家了包含两个sale项的列表，也就是包含两个自定义元组。我们也可以使用索引位置来引用元组中的项----比如，第一个销售项的价格为sales[0][-1]，但我们呢也可以使用名称进行引用，这样会更加清晰：

命名的元组提供的清晰与便利通常都是有用的，比如，下面另一个例子：

私有方法namedtuple._asdict()返回的是键-值对的映射，其中每个键都是元组元素的名称，值则是对应的值，我们使用映射拆分将映射转换为str.format()方法的键-值参数。

“{manufacturer} {model}”.format(**aircraft._asdict())

字符串

str,字符串在python中是有序序列，这意味着字符串在python中可以做很多操作，比如slice。不过有一点是字符串中某部分无法进行修改，因为是不可变对象。

字符串经常碰到的一个问题就是怎么把 字符串倒序输出。

这时候我们就可以把slice用到字符串中，编写一个倒序输出的函数如下：

def reverse（x）：
    if not isinstance(x,basestring):
       raise TypeError ("bad type");
    else:
        return x[::-1]

isinstance是用来判断参数是否是字符串，如果不是的话将会报错。

basestring是str和unicode的父类，可以用来分辨是不是字符串的类型。

推荐学习：Python视频教程

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!