Was sind die Python-Sequenztypen?

Welche Sequenztypen gibt es in Python? Was ist ein Sequenztyp in Python? Erfahren Sie mehr darüber in diesem Artikel.

Sequenz : Zeichen, Liste, Tupel

Alle Sequenzen unterstützen Iteration

Sequenz Stellt eine dar geordnete Sammlung von Objekten, deren Index eine nicht negative Ganzzahl ist

Zeichen und Tupel gehören zu unveränderlichen Sequenzen, und Listen sind veränderlich

1) Zeichen

String-Literal: Setzen Sie den Text in einfache Anführungszeichen, doppelte Anführungszeichen oder dreifache Anführungszeichen >

    '    ''    '''
        >>> str1 = ' hello, fanison '
        >>> type(str1)
        str

 

Dokumentationszeichenfolge: Wenn die erste Anweisung eines Moduls, einer Klasse oder einer Funktion aus einem Zeichen besteht, wird die Zeichenfolge zu einer Dokumentationszeichenfolge und kann mit dem __doc__-Attribut referenziert werden; Beispiel:

        >>> str2 = u'你好，fanison'
        >>> type(str2)
        unicode

Operator:

Indexoperator                                                                                                                      . Slice

Erweiterter Slice-Operator s[i:j:stride]

Beispiel:

rrree

Hinweis:

Schritt Wenn es positiv ist, bedeutet dies, dass der Index von klein nach groß genommen wird

Wenn Der Schritt ist negativ, das bedeutet, dass er rückwärts gemacht wird und der Index von groß nach klein geht. i > usw.

                                                                                                                                           >

min(s)             Der Minimalwert von s

max(s)             Der Maximalwert von. s

                                                                                               [,Ende ]]) Finden Sie die Position, an der das angegebene String-Sub zum ersten Mal erscheint

S.upper() Wandeln Sie einen String in Großbuchstaben um

S.lower() Wandeln Sie einen String in Kleinbuchstaben um

s.join (t) Verwenden Sie S als Trennzeichen, um den Zeichenfolgen in der Sequenz t

            >>> def printName():
                    "the function is print hello"
                    print 'hello'
            >>> printName.__doc__

Hinweis:

Verwenden >>> help(str.join)

                                                                                                                    : Containertyp

Eine geordnete Sammlung beliebiger Objekte, auf deren Elemente über einen Index zugegriffen wird, variable Objekte, variable Länge, heterogen, beliebige Verschachtelung

Unterstützt Ändern

an Ort und Stelle Ändern des angegebenen Indexelements, Ändern des angegebenen Shards, Löschanweisung, integrierte Methode

                                              Weil es Unterstützt das Original. Ändern Sie die Speicherposition. Sie können ID () verwenden, um die Positionsänderung anzuzeigen.

Integrierte Methode:

Berechnung von L.Count (Wert). Der Wertwert erscheint die Anzahl der Male) fügen Sie eine zusammengeführte Liste hinzu (der Inhalt der zweiten Liste wird als einzelnes Element bis zum Ende angehängt)

            >>> str3 = 'hello,fanison'
            >>> str2[0:]
            'hello,fanison'      返回所有元素
            >>> str2[0:7]
            'hello,f'            返回索引7之前的所有元素
            >>> str2[0:7:2]
            'hlof'               返回从索引0到6内步径为2的元素，即隔一个取一个
            >>> str2[7:0:-2]        
            'a,le'               从索引7处倒着隔一个取一个取到索引1处
            >>> str2[-4:-1]
            'iso'                从索引-4处取到-2处       
            >>> str2[-4::-1]
            'inaf,olleh'         从-4处到开始处倒着取

Verschieben Sie das Element, dessen Wert der Schlüssel

 >>> l1 = list(str1)
>>> l1
['h', 'e', 'l', 'l', 'o', ',', 'f', 'a', 'n', 'i', 's', 'o', 'n']
>>> ''.join(l1)
'hello,fanison'             使用空字符作为分隔符连接列表l1
S.replace(old, new[, count])             替换一个字符串
>>> str1.replace('fan','FAN')
'hello,FANison'

                                                                                                                                         using   using   using   using           using using ' ' s ' ' s ' durch ' s durch aus ‐ ‐ ‐ ‐‐ ‐ ‐

L.insert(index, object) 在索引index处插入值

                        >>> l1.insert(1,'abc')
                        >>> l1
                        ['x', 'abc', 2, 75]

L.sort() 排序

L.reverse() 逆序

                        >>> l1.sort()
                        [2, 75, 'abc', 'x']
                        >>> l1.reverse()
                        ['x', 'abc', 75, 2]

l1 + l2: 合并两个列表，返回一个新的列表；不会修改原列表；

                        >>> l1 = [ 1,2,3]
                        >>> l2 = [ 'x','y','z']
                        >>> l1 + l2
                        [1, 2, 3, 'x', 'y', 'z']

l1 * N: 把l1重复N次，返回一个新列表;

                        >>> l1 * 3
                        [1, 2, 3, 1, 2, 3, 1, 2, 3]         使用id()查看是否生成新列表

成员关系判断字符：

in 用法： item in container

not in item not in container

                            >>> l1 = [ 'x','y',3 ]
                            >>> 'y' in l1
                            True
                            >>> 'x' not in l1
                            False

列表解析：[]

列表复制方式：

浅复制:两者指向同一内存对象

                    >>> l1 = [ 1,2,3,4 ]
                    >>> l2 = l1
                    >>> id(l1) == id(l1)
                    True                            可以看出两者内存地址相同
                    >>> l1.append('x')
                    >>> print l1
                    [ 1,2,3,4,'x' ]
                    >>> print l2
                     [ 1,2,3,4,'x' ]

深复制：两者指向不同内存对象

1)导入copy模块，使用deepcoop方法

                     >>> import copy
                     >>> l3 = copy.deepcopy(l1)
                     >>> id(l3) == id(l1)
                     False                          地址不同

2)复制列表的所有元素，生成一个新列表

                    >>> l4 = l1[:]              
                    >>> print l4
                    [ 1,2,3,4,'x' ]
                    >>> l1.append(6)
                    >>> print l1
                    [ 1,2,3,4,'x',6 ]               l1改变
                    >>> print l4
                    [ 1,2,3,4,'x' ]                 l4不变

3)元组

表达式符号：()

容器类型

任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定，异构，嵌套

常见操作：

                    >>> t1 = ( 1,2,3,'xyz','abc')
                    >>> type(t1)
                    tuple
                    >>> len(t1)
                    5
                    >>> t2 = ()                             定义一个空元组
                    >>> t3 = ( , )
                    SyntaxError: invalid syntax             报错：使用逗号分隔的条件是最少要有一个元素

(1,)

                    >>> t1[:]
                    ( 1,2,3,'xyz','abc' )
                    >>> t1[1:]
                    (2, 3, 'xyz', 'abc')

(1,2)

                    >>> t1[1:4]
                    (2, 3, 'xyz')
                    >>> t4 = 'x',1,'yz',45,[2,4,6]              注意!!!这样也可以生成元组
                    >>> t4  
                    ('x', 1, 'yz', 45, [2, 4, 6])

t1 + t4: 合并两个元组，返回一个新的元组；不会修改原元组；

                    >>> t1 + t4
                    (1, 2, 3, 'xyz', 'abc', 'x', 1, 'yz', 45, [2, 4, 6])

t1 * N: 把l1重复N次，返回一个新元组;

                    >>> t1 * 3
                    (1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc', 1, 2, 3, 'xyz', 'abc')

成员关系判断

in

not in

注意：

虽然元组本身不可变，但如果元组内嵌套了可变类型的元素，那么此类元素的修改不会返回新元组；

例：

                    >>> t4 = ('x', 1, 'yz', 45, [2, 4, 6])
                    >>> id(t4)
                    44058448
                    >>> t4[4]                           
                    [2, 4, 6]
                    >>> t4[4].pop()                     弹出列表内一个元素
                    6
                    >>> print t4[4]
                    [2, 4]
                    >>> print t4
                    ('x', 1, 'yz', 45, [2, 4]) 
                    >>> id(t4)
                    44058448                            由此可见，对元组内列表内的修改也会使元组发生改变，没有返回新元组

Das obige ist der detaillierte Inhalt vonWas sind die Python-Sequenztypen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!