Welche Sequenzen sind Listen, Tupel und Strings in Python?

Listen, Tupel und Strings sind geordnete Sequenzen in Python; Listen sind veränderliche Objekte, während Tupel und Strings unveränderliche Objekte sind. Jedem Element in der Sequenz wird eine Nummer zugewiesen, die seine Position oder seinen Index darstellt, wobei der erste Index 0, der zweite Index 1 usw. ist.

Sequenz ist die grundlegendste Datenstruktur in Python. Jedem Element in der Sequenz wird eine Nummer zugewiesen – seine Position oder sein Index, wobei der erste Index 0, der zweite Index 1 usw. ist.

Zu den Operationen, die an Sequenzen ausgeführt werden können, gehören das Indizieren, Schneiden, Hinzufügen, Multiplizieren und Überprüfen von Mitgliedern. Darüber hinaus verfügt Python über integrierte Methoden zur Bestimmung der Länge einer Sequenz und zur Bestimmung der größten und kleinsten Elemente.

Listen, Tupel und Strings sind geordnete Sequenzen in Python; Listen sind veränderliche Objekte, während Tupel und Strings unveränderliche Objekte sind.

Liste (Liste)

Eine Liste ist eine geordnete Sequenz, die 0 oder mehr Objektreferenzen enthält und dieselbe Sharding- und Schrittsyntax wie Zeichenfolgen und Tupel unterstützt. Im Gegensatz zu Strings und Tupeln sind Listen veränderbar, sodass wir Elemente in der Liste löschen oder ersetzen sowie Slices in der Liste einfügen, ersetzen oder löschen können.

Der Listendatentyp kann als Funktion list() aufgerufen werden. Beim Aufruf ohne Parameter wird eine leere Liste zurückgegeben. Bei allen anderen Parametern wird eine flache Kopie des Parameters zurückgegeben Give Konvertiert ein gegebenes Objekt in eine Liste. Der Funktionswert akzeptiert einen Parameter. Listen können auch ohne die Funktion list() erstellt werden, leere Listen können mit leeren eckigen Klammern erstellt werden und Listen mit einem oder mehreren Elementen können mit einer durch Kommas getrennten Folge von Datenelementen (eingeschlossen in []) erstellt werden.

Von Listen bereitgestellte Methoden:

Jeder iterierbare Datentyp (Liste, Tupel usw.) kann mit dem Sequenzteilungsoperator aufgeteilt werden, nämlich: * . Wenn es verwendet wird, um zwei oder mehr Variablen links vom Operator zuzuweisen, von denen eine mit * eingeleitet wird, wird das Datenelement dieser Variablen zugewiesen, und alle übrigen Datenelemente werden der mit einem Sternchen versehenen Variablen zugewiesen, siehe unten. Einige Beispiele :

Wenn der Sequenzaufteilungsoperator auf diese Weise verwendet wird, werden der Ausdruck *rest und ähnliche Ausdrücke als mit einem Sternchen versehene Ausdrücke bezeichnet.

Python hat auch ein verwandtes Konzept: mit Sternchen versehene Parameter.

Wissenschaftliche Forschung führt eine iterative Verarbeitung der Datenelemente in der Liste durch. Das verwendete Syntaxformat ist für Element in L:. Wenn Sie die Datenelemente in der Liste ändern müssen, lautet die übliche Methode wie folgt:

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

Da die Liste Sharding unterstützt, kann in mehreren Fällen dieselbe Funktion mithilfe von Sharding oder einer Listenmethode ausgeführt werden, z. B.: Gegeben List woods=['Cedar','Yew','Fir'], wir können die Liste auf die folgenden zwei Arten erweitern:

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

Für die beiden oben genannten Methoden ist das Ergebnis die Liste ['Cedar','Yew' ,'Tanne','Kauri','Lärche'].

Mit der Methode list.append() kann ein einzelnes Datenelement am Ende der Liste hinzugefügt werden. Datenelemente können an jeder Indexposition mit der Methode list.insert() (oder durch Zuweisung zu einem Slice der Länge 0) in die Liste eingefügt werden. Wenn beispielsweise die Liste woods=['Cedar','Yew','Fir','Spruce'] gegeben ist, können wir ein neues Datenelement an Indexposition 2 einfügen (d. h. als drittes Element der Liste). Die folgenden zwei Methoden können implementiert werden:

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

Die mit den beiden oben genannten Methoden erhaltenen Ergebnisse sind Listen ['Zeder', 'Eibe', 'Kiefer', 'Tanne', 'Fichte'].

Durch Angabe der Indexposition Indem Sie dem Objekt einen Wert zuweisen, können Sie ein einzelnes Datenelement in der Liste ersetzen, beispielsweise woods[2]='Redwood'. Indem Sie einem Shard ein Iterable zuweisen, können Sie das gesamte Shard ersetzen, zum Beispiel woods[1:3]=['Spruce','Sugi','Rimu'], und die Shard-Iterables müssen nicht gleich sein Länge. In all diesen Fällen werden die Datenelemente des Shards entfernt und die Datenelemente des Iterables eingefügt. Wenn das Iterable weniger Elemente enthält als das zu ersetzende Fragment, wird die Kategorie durch diese Operation kürzer, andernfalls wird die Liste kürzer. Das folgende Beispiel:

Für komplexe Listen können Sie eine for...in-Schleife verwenden, um sie zu erstellen. Wenn Sie beispielsweise eine Liste von Schaltjahren innerhalb eines bestimmten Zeitbereichs erstellen müssen, können Sie die verwenden folgende Aussagen:

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

Zwei Ausdrücke:

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

tupel

元组是个有序的序列，其中包含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视频教程

Das obige ist der detaillierte Inhalt vonWelche Sequenzen sind Listen, Tupel und Strings in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!