Quels sont les types de séquences Python ?

Quels sont les types de séquences en python ? Qu'est-ce qu'un type séquence en Python ? Apprenez-en plus à ce sujet dans cet article.

Séquence  : caractère, liste, tuple

Toutes les séquences prennent en charge l'itération

séquence Représente un collection ordonnée d'objets dont l'index est un entier non négatif

Les caractères et les tuples appartiennent à des séquences immuables, et les listes sont mutables

1) Caractères

Chaîne littérale : mettez le texte entre guillemets simples, doubles ou triples

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

Si vous souhaitez utiliser l'encodage Unicode, utilisez le caractère u avant le caractère pour l'identifier

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

 

Chaîne de documentation : si la première instruction d'un module, d'une classe ou d'une fonction est un caractère, la chaîne devient une chaîne de documentation et peut être référencée à l'aide de l'attribut __doc__ ; Exemple :

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

Opérateur :

Opérateur d'index         s[i]                                                                                                                                 . >

Exemple :

            >>> 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处到开始处倒着取

Remarque :

step S'il est positif, cela signifie que l'index est pris de petit à grand j

Si. le pas est négatif, cela signifie qu'il est pris en arrière et l'index va du grand au petit i > >Opérations de support :

Index, découpage, min(), max(), len(), etc.

>

min (s) La valeur minimale de s

max (s) la valeur maximale de s

(sub [, start [, end ]]) Trouver la position où la chaîne spécifiée apparaît en premier

S.upper() Convertir une chaîne en majuscule

S.lower() Convertir une chaîne en minuscule

S.join(t)                                                                                                                                                                                                Utilisez s comme délimiteur pour joindre les chaînes dans la séquence t

 >>> 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'

Remarque : 🎜>

Utilisez help( ) Obtenez son aide

>>> help(str.join)

                                                                                                                                            : type de conteneur

Une collection ordonnée d'objets arbitraires, accédant aux éléments via un index, des objets variables, une longueur variable, une imbrication hétérogène et arbitraire

Prise en charge Modifier

en place Modifier l'élément d'index spécifié, modifier le fragment spécifié, l'instruction de suppression, la méthode intégrée

             Parce qu'il prend en charge l'original Modifiez la position de la mémoire, vous pouvez utiliser ID () pour visualiser son changement d'emplacement

Méthode intégrée :

L.Count (Valeur) calcul de la valeur apparaît Nombre de fois ) Ajouter une liste fusionnée (le contenu de la deuxième liste sera ajouté à la fin en tant qu'élément unique)

         >>> list1 = [ 1,2,3,'x','n' ]
         >>> list1[1]=56
         >>> print list1
         [1, 56, 3, 'x', 'n']
         >>> list1[1:3]=[]              会删除索引1到索引3之前的元素
         >>> print list1
         [1, 'x', 'n']   
         >>> del(list1[1])              使用del函数删除list索引为1的元素
         >>> print list1
         [1, 'n']

                                                                                                                                                      Déplacer Diviser l'élément dont la valeur est clé

      >>> l1 = [ 1,2,3 ]
                        >>> l2 = [ 'x','y','z']
                        >>> l1.append(l2)
                        >>> l1
                        [1, 2, 3, ['x', 'y', 'z']]          使用append方法会以其原有存在形式追加
                        >>> l1 = [ 1,2,3 ]
                        >>> l1.extend(l2)
                        >>> l1
                        [1, 2, 3, 'x', 'y', 'z']            注意两种增加的区别

                                                                                                                                       

                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                            由此可见，对元组内列表内的修改也会使元组发生改变，没有返回新元组

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!