파이썬 시퀀스 유형은 무엇입니까?

파이썬의 시퀀스 유형은 무엇인가요? Python의 시퀀스 유형이란 무엇입니까? 이 기사에서 이에 대해 자세히 알아보세요.

Sequence: 문자, 목록, 튜플

모든 시퀀스는 반복을 지원합니다# 🎜🎜 #

A 시퀀스는 인덱스가 음수가 아닌 정수인 객체의 순서가 지정된 컬렉션을 나타냅니다.

문자와 튜플은 변경할 수 없는 시퀀스에 속하고 목록은 변경할 수 있습니다.

# 🎜🎜 #

1)문자

문자열 리터럴: 텍스트를 작은따옴표, 큰따옴표 또는 삼중따옴표로 묶습니다.

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

#🎜 🎜 #

유니코드 인코딩을 사용하려면 문자 앞에 u 문자를 사용하여 식별하세요.

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

             

문서 문자열: 모듈의 첫 번째, 클래스 또는 함수 명령문이 문자인 경우 문자열은 문서 문자열이 되며 __doc__ 속성을 사용하여 참조할 수 있습니다.

Example:

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

Operator:

#索#i s [i] 시퀀스의 요소를 반환합니다 I#🎜🎜 ## 🎜🎜#切 [S [i: j] 슬라이스로 돌아가기#🎜🎜 ## 🎜🎜#확장 슬라이스 연산자 s s [i: j:스트라이드]

                                                                                  > :

은 보폭이 긍정적이라는 의미입니다. 작은 것에서 큰 것 i

단계가 음수이면 인덱스를 큰 것에서 작은 것으로 거꾸로 가져간다는 의미입니다. i > 지원 작업:

Index, slicing, min(), max(), len() 등

           

len(s)         s 요소 수

min(s)                                                                                        > 이 지정된 문자열 sub가 처음 나타나는 위치

S.upper() 문자열을 소문자로 변환 s를 구분 기호로 사용하여 시퀀스 t String in

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

참고: # 🎜🎜#

도움말을 얻으려면 help()를 사용하세요

>>> help(str.join)

                                                                                                        모든 개체의 순서에 따른 수집, 접근 인덱스를 통한 요소, 가변 객체, 가변 길이, 이종, 임의 중첩

​

​ 내부 수정 지원

# 🎜🎜# 지정된 인덱스 요소 수정, 지정된 샤드 수정, 명령문 삭제, 내장 메소드

🎜# 원래 Modified를 모든 곳에서 지원하므로 메모리 위치는 변경되지 않습니다. id()를 사용하여 위치 변경 사항을 볼 수 있습니다. ㅋㅋ  ' s ' s ' s ‐ ‐ ‐ ​ ​ ​                                                             ~로          )                  > > 값 값이 나타납니다

##🎜 🎜# 🎜🎜#

                                                                                                                  L. 목록의 내용은 단일 요소로 끝에 추가됩니다.)

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

                L.pop([index])                                              ' ' ' s ' ' s에서 't's'' t ‐ ‐ ‐‐                                                                                                  to                                           # ### l#l.Remove (key) key

🎜🎜

🎜🎜#l에 대한 키가 있는 요소를 제거합니다. INDEX(값) 지정 위치.

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

위 내용은 파이썬 시퀀스 유형은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!