Python序列类型

序列:字符、列表、元组

    所有序列都支持迭代
    序列表示索引为非负整数的有序对象集合
    字符和元组属于不可变序列,列表可变

1)字符

    字符串字面量:把文本放入单引号、双引号或三引号中;    ‘    ‘‘    ‘‘‘
        >>> str1 = ‘ hello, fanison ‘
        >>> type(str1)
        str
    
    如果要使用unicode编码,则在字符之前使用字符u进行标识        >>> str2 = u‘你好,fanison‘
        >>> type(str2)
        unicode
        
    文档字串:模块、类或函数的第一条语句是一个字符的话,该 字符串就成为文档字符串,可以使用__doc__属性引用;
        例:            >>> def printName():
                    "the function is print hello"
                    print ‘hello‘
            >>> printName.__doc__
            
    运算符:
        索引运算符          s[i]        返回一个序列的元素i
        切片运算符          s[i:j]      返回一个切片
        扩展切片运算符      s[i:j:stride]
      
        例:            >>> 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处到开始处倒着取
        注意:
            步径为正表示  正着取,索引从小到大          i < j
            步径为负表示  倒着取,索引从大到小          i > j
        
    支持运算:
        索引、切片、min()、max()、len()等
        
            len(s)              s中的元素个数
            min(s)              s的最小值
            max(s)              s的最大值
            
   支持方法:
        S.index(sub [,start [,end]])            找到指定字符串sub首次出现的位置
        S.upper()                               将一个字符串转换为大写形式
        S.lower()                               将一个字符串转化为小写形式
        S.join(t)                               使用s作为分隔符连接序列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‘
    注意:
        使用 help()获取其帮助                >>> help(str.join)

2)列表

列表:容器类型
         任意对象的有序集合,通过索引访问其中的元素,可变对象,长度可变,异构,任意嵌套
     
      支持在原处修改
            修改指定的索引元素,修改指定的分片,删除语句,内置方法            
         >>> 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‘]
            注意:
                 因为支持原处修改,不会改变内存位置,可使用  id() 查看其位置变化
       
       内置方法:
                 L.count(value)                     计算value值出现的次数
                 L.append(object)                   将一个新元素追加到L末端                    
                 L.extend(iterable)                 增加合并列表(第二个列表内容会以单个元素追加至末端)                        >>> 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.pop([index])                      返回元素index并从列表中移除它,如果省略则返回并移除列表最后一个元素
                L.remove(key)                       移除值为key的元素                        >>> l1 = [ ‘x‘,2,‘abc‘,16,75 ]                        >>> l1.pop(2)                       pop方法是按索引移除                        ‘abc‘
                        >>> l1
                        [‘x‘, 2, 16, 75]                        >>> l1.remove(16)                   remove方法是按值移除                        >>> l1
                        [‘x‘, 2, 75]  
                L.index(value)                        指定值首次出现的位置
                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                            由此可见,对元组内列表内的修改也会使元组发生改变,没有返回新元组
时间: 2024-12-04 23:35:34

Python序列类型的相关文章

python 序列类型

1.不可变的序列类型:tuple.range.str.set 001:对于tuple 类型有如下几种构造方式 1.() 构造一个空的元组. 2.a | (a,) 构造一个只有一个元素的元组. 3.tuple('1') 使用内置的tuple方法构造. 4.(1,2,3) 使用字面值的方法来构造一个元组. 002:对于range就没有这么多的花样了,只有一个构造方法可用 range(起始索引,结束索引,步长) 003:str 也没有太多的花样:它主要用字面值来构造,这些字面值可以用单引号,双引号,三

python序列类型及一些操作

序列分类 1.按存放的数据类型分类: 容器类型(能存放不同类型的数据):list.tuple.coolections.deque 扁平序列(只能存放一种类型的数据):str.bytes.bytearray.memoryview.array.array 容器类型存放它们所包含的任意类型的对象的引用,而扁平类型存放的是值而不是引用.(扁平序列是一段连续的存储空间) 2.按能否被修改分类: 可变序列:list.bytearray.array.array.coolections.deque.memory

Python序列类型之字符串详解

字符串(str)关于引号:Python中有3种引号.分为单引号.双引号.三引号.python中单引号’'和双引号""没有区别,如a=’abc’,a=’’abc’’.三引号就是连敲三次单引号,不表示字符串,它用来多行注释,并且多行注释没结束(没出现第二个三引号)可以随便换行.若引号中还要加引号需要交叉使用,即外面单引号里面双引号,外面双引号里面单引号.一对单引号或双引号加上引号内的字符就是字符串,字符串中间不可以换行,想换行显示在换行处敲一个\n. >>> a='abc

python中非序列类型期望值拷贝的解决方案

看下面这段代码: # -*- coding: utf-8 -*-import copy class Present(object):    def __init__(self, str_cmd):        self._str_cmd = str_cmd        print "进入Present时的地址:", id(self._str_cmd) def set_value(self):        temp = "test_cmd"        sel

Python基本语法_基本数据类型_序列类型详解

目录 目录 序列 序列的标准操作符 切片操作符 一个例子 序列的功能函数 enumerate 枚举出序列对象的元素 len 获取序列对象的长度 min 取出sequence中的最小值 max 取出sequence中的最大值 reversed 返回一个逆序访问的迭代器 sorted 序列的排序 sum 计算序列中的各项元素和 zip 混合两个序列对象 all 检测sequence中各项元素是否均为True any 检测序列中的任意元素是否为True 序列 序列是一类基本数据类型(字符串/列表/元组

Python学习之通用序列类型数据详解

本文和大家分享的主要是python通用序列类型数据的相关操作,一起来看看吧,希望对大家学习python有所帮助. Python的序列,Python有6种内建的序列,包括:列表.元组.字符串.Unicode字符串.buffer对象和xrange对象.其中最为常用的是Python的列表和元组. Python的序列 Python有6种内建的序列,包括:列表.元组.字符串.Unicode字符串.buffer对象和xrange对象.其中最为常用的是Python的列表和元组. Python序列的应用 Pyt

Python 列表API 序列类型 &nbsp; 列表生成

列表API: 1.pop( )  :按照索引弹出元素,返回值为该元素.默认弹出最后一个元素: 例如:a=[1,2,3]; print(a.pop()); 输出结果是3 pop(正值) 从索引位置 pop(负值) 从列表倒数位置开始指定下标 2.remove( ):按照元素值弹出第一个匹配项,返回新列表 lists=[123,'xyz','zara','abc','xyz']   xyz元素从列表中移除  abc弹出 结果是:[123,'zara','abc'] abc 例如: lists=[12

Python的数值类型与序列类型

先说一下基本学习要用的一些基本软件: 1.vmware,和virtualbox,:是两款虚拟软件,用于创建虚拟机供使用. 2.ubuntu:一款基于Linux开发的操作系统. 3.Python:Python里面包含的Python解释器. 4.xshell:远程连接控制软件. 5.pycharm:专门为Python开发的一款IDLE. 这个几个软件或者说工具,需要进行配合才能使程序运行起来,配合需要相互配置,相互协调,这个是个难点,需要多加练习. 程序就是需要多加练习,多加学习才能完全去了解他们,

6、python基本数据类型之序列类型

前言:python的基本数据类型可以分为三类:数值类型.序列类型.散列类型,本文主要介绍序列类型及其通用操作 一.序列类型 1)字符串(str):用单引号('),双引号("),三引号(三单引号'''或三双引号""")来表示 2)列表(list):用[ ]中括号表示 3)元组(tuple):用()小括号表示 二.字符串str 1.定义 字符串定义:单引号.双引号.三引号.str() 引号都是成对出现 空字符串:s ='' (单引号对里没有任何数据) 空字符:s ='