精华内容
下载资源
问答
  • 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后 一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 python 常见序列对比: 比较项 列表 元组 字典 集合 类型...

    Python序列类似于其他语言中的数组,但功能要强大很多。

    Python中常用的序列结构有列表、元组、字符串,字典、集合以及range等对象也支持很多类似的操作。

    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后 一个元素下标为-1,倒数第二个元素下标为-2,以此类推。

    python 常见序列对比:

    比较项 列表 元组 字典 集合
    类型名称 list tuple dict set
    定界符 方括号[] 圆括号() 大括号{} 大括号 {}
    是否可变
    是否有序
    是否支持下标 是(使用序号作为 下标) 是(使用序号作 为下标) 是(使用“键”作为下标)
    元素分隔符 逗号 逗号 逗号 逗号
    对元素形式的要求 键:值 必须可哈希
    对元素值的要求 必须可哈希 必须可哈希
    元素是否可重复 “键”不允许重 复,“值”可以重复
    元素查找速度 非常慢 很慢 非常快 非常快
    新增和删除元素速度 尾部操作快,其他位置慢 不允许

    列表

    • 列表是Python中内置有序、可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号分 隔开;
    • 当列表元素增加或删除时,列表对象自动进行扩展或收缩内存,保证元素之间没有缝隙;
    • 在Python中,一个列表中的数据类型可以各不相同,可以同时分别为整数、实数、字符串等基 本类型,甚至是列表、元组、字典、集合以及其他自定义类型的对象。

    列表常用方法:

    方法 说明
    lst.append(x) 将元素x添加至列表lst尾部
    lst.extend(L) 将列表L中所有元素添加至列表lst尾部
    lst.insert(index, x) 在列表lst指定位置index处添加元素x,该位置后面的所有元素后移 一个位置
    lst.remove(x) 在列表lst中删除首次出现的指定元素,该元素之后的所有元素前移一 个位置
    lst.pop([index]) 删除并返回列表lst中下标为index(默认为-1)的元素
    lst.clear() 删除列表lst中所有元素,但保留列表对象
    lst.index(x) 返回列表lst中第一个值为x的元素的下标,若不存在值为x的元素则 抛出异常
    lst.count(x) 返回指定元素x在列表lst中的出现次数
    lst.reverse() 对列表lst所有元素进行逆序
    lst.sort(key=None, reverse=False) 对列表lst中的元素进行排序,key用来指定排序依据,reverse决定 升序(False)还是降序(True)
    lst.copy() 返回列表lst的浅复制
    • lst.reverse(),lst.sort()

      >>> arr = list(range(10))
      >>> arr
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> arr.reverse()					#逆序
      >>> arr 	
      [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
      >>> arr.sort()						#排序
      >>> arr
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      

    浅复制,浅层次的复制,深复制

    >>> arr = [1,2,3]
    >>> arr = [1,2,3]
    >>> arr1 = arr                   # 直接赋值 arr 和 arr1 共用内存  也就是说他们还是一个
    >>> id(arr),id(arr1)
    (2909054945928, 2909054945928)
    >>> arr1[0] = 123
    >>> arr                          #修改一个另一个也会改变
    [123, 2, 3]
    >>> arr2 = arr.copy()            #浅复制,
    >>> id(arr),id(arr2)             #不共用内存了
    (2909054945928, 2909053356424)   
    >>> arr2[0]=321					#修改一个另一个不会改变
    >>> arr
    [123, 2, 3]
    >>> arr = [[1],2,3]				#但是列表里面有可变序列时,可变序列改变 原来的也会改变
    >>> arr2 = arr.copy()
    >>> arr2[0].append(2)
    >>> arr							#在arr2里添加,arr里面也有了
    [[1, 2], 2, 3]
    >>> import copy					#标准库copy
    >>> arr
    [[1, 2], 2, 3]
    >>> arr3 = copy.deepcopy(arr)    #深复制
    >>> arr3
    [[1, 2], 2, 3]          
    >>> arr3[0].pop() 					#arr3内层序列改变  arr不受影响
    2
    >>> arr								
    [[1, 2], 2, 3]
    

    列表的索引:

    • 下标索引
    >>> arr = list(range(20))
    >>> arr
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    >>> arr[2]
    2
    >>> arr[0]
    0
    >>> arr[-2]   #可以双向来
    18
    
    • 切片
      • 切片适用于列表、元组、字符串、range对象等类型,但作用于列表时功能强大。可以使用切片来截取列表中的任何部分,得到一个新列表,也可以通过切片来修改和删除列表中部分元素,甚至可以通过切片操作为列表对象增加元素。
      • 切片使用2个冒号分隔的3个数字来完成:[start: end: step]
        1. 第一个数字表示切片开始位置(默认为0)。
        2. 第二个数字表示切片截止(但不包含)位置(默认为列表长度)。
        3. 第三个数字表示切片的步长(默认为1),当步长省略时可以顺便省略后一个冒号
      • 切片操作不会因为下标越界而抛出异常,而是简单地在列表尾部截断或者返回一个空列表,代码具有更强的健壮性。
    >>> lit = list(range(5))
    >>> lit
    [0, 1, 2, 3, 4]
    >>> lit[1:]
    [1, 2, 3, 4]
    >>> lit[:3]
    [0, 1, 2]
    >>> lit[:-3]
    [0, 1]
    >>> lit[1::2]
    [1, 3]
    >>> lit[:3:2]
    [0, 2]
    >>> lit[1::2]=[111,111]
    >>> lit							#可以使用切片来原地修改列表内容
    [0, 111, 2, 111, 4]
    
    >>> lit2 = lit[::]              #切片返回的是列表元素的浅复制
    >>> lit2
    [0, 111, 2, 111, 4]
    >>> lit2[1]=222
    >>> lit
    [0, 111, 2, 111, 4]
    >>> lit2
    [0, 222, 2, 111, 4]
    

    列表推导式

    列表推导式使用非常简洁的方式来快速生成满足特定需求的列表,代码具有非常强的可读性。

    列表推导式语法形式为:
    [expression for expr1 in sequence1 if condition1
                for expr2 in sequence2 if condition2
                for expr3 in sequence3 if condition3
                ...
                for exprN in sequenceN if conditionN]
    

    列表推导式在内部实际上是一个循环结构,只是形式更加简洁,例如:

    >>> aList = [x*x for x in range(10)]
    >>> aList
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    使用列表推导式实现嵌套列表的平铺:

    >>> vec = [[1,2,3], [4,5,6], [7,8,9]] 
    >>> [num for elem in vec for num in elem] 
    [1, 2, 3, 4, 5, 6, 7, 8, 9] 
    

    再如取偶数:

    >>> arr = list(range(10))
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> [i for i in arr if i%2==0]
    [0, 2, 4, 6, 8]
    >>> [i for i in range(30) if i%2==0]
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
    

    元组

    • 元组和列表类似,但属于不可变序列,元组一旦创建,用任何方法都不可以修改其元素。

    • 元组的定义方式和列表相同,但定义时所有元素是放在一对圆括号“()”中,而不是方括号中。

      列表和元组的区别

      1. 列表是动态数组,他们可变且可以重设长度(改变其内部元素的个数)。
      2. 元组是静态数组,他们不可变,且其内部数据一旦创建便无法改变。
      3. 元组缓存与Python运行时环境,这意味着我们每次使用元组时无须动态访问内核去分配内存。

      列表和元组都可以接受混合类型。

      >>> t = tuple(range(5))
      >>> t
      (0, 1, 2, 3, 4)
      >>> t[1]=22
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: 'tuple' object does not support item assignment
      

    生成器推导式

    生成器推导式的结果是一个生成器对象。使用生成器对象的元素时,可以根据需要将其转化为列表或元组,也可以使用生成器对象__next__()方法或内置函数next()进行遍历,或者直接将其作为迭代器对象来使用。

    生成器对象具有惰性求值的特点,只在需要时生成新元素,比列表推导式具有更高的效率,空间占用非常少,尤其适合大数据处理的场合。

    不管用哪种方法访问生成器对象,都无法再次访问已访问过的元素。

    >>> g = (i for i in range(10))
    >>> next(g)
    0
    >>> next(g)
    1
    >>> g.__next__()
    2
    >>> list(g)
    [3, 4, 5, 6, 7, 8, 9]
    >>> g = (i for i in range(10))
    >>> 5 in g    #找到5时 3已经遍历过了  所以 下面找不到3
    True
    >>> 3 in g    #但会继续往下找  直到遍历了所有的元素
    False
    >>> 6 in g    #所有6也在上次查找时被遍历了
    False
    >>> g = (i for i in range(10))
    >>> 3 in g
    True
    >>> 5 in g
    True
    

    补充序列解包

    序列解包是Python中非常重要和常用的一个功能,可以使用非常简洁的形式完成复杂的功能,提高了代码可读性,减少了代码输入量。

    • 可以使用序列解包功能对多个变量同时赋值
    >>> x, y, z = 1, 2, 3
    >>> print(x,y,z)
    1 2 3
    >>> v_tuple = (4, 5, 6)
    >>> x, y, z = v_tuple
    >>> print(x,y,z)
    4 5 6
    >>> x, y, z = range(7,10)
    >>> print(x,y,z)
    7 8 9
    
    • 更多的使用
    >>> x, y, z = range(3)            #可以对range对象进行序列解包
    >>> x, y, z = iter([1, 2, 3])     #使用迭代器对象进行序列解包
    >>> x, y, z = map(str, range(3))  #使用可迭代的map对象进行序列解包
    >>> a, b = b, a                   #交换两个变量的值
    >>> x, y, z = sorted([1, 3, 2])   #sorted()函数返回排序后的列表
    >>> a, b, c = 'ABC'               #字符串也支持序列解包
    >>> x = [1, 2, 3, 4, 5, 6]
    >>> x[:3] = map(str,range(5))     #切片也支持序列解包
    >>> x
    ['0', '1', '2', '3', '4', 4, 5, 6]
    
    • 序列解包遍历多个序列
    >>> keys = ['a', 'b', 'c', 'd']
    >>> values = [1, 2, 3, 4]
    >>> for k, v in zip(keys, values):
    	  print((k, v), end=' ')
    
    ('a', 1) ('b', 2) ('c', 3) ('d', 4) 
    
    • 对字典也适用
    >>> s = {'a':1, 'b':2, 'c':3}
    >>> b, c, d = s.items()
    >>> b
    ('c', 3)
    >>> b, c, d = s
    >>> b
    'c'
    >>> b, c, d = s.values()
    >>> print(b, c, d)
    1 3 2
    

    字典

    • 字典是无序、可变序列。

    • 定义字典时,每个元素的键和值用冒号分隔,元素之间用逗号分隔,所有的元素放在一对大括号“{}”中。

    • 字典中的键可以为任意不可变数据,比如整数、实数、复数、字符串、元组等等。

      • globals()返回包含当前作用域内所有全局变量和值的字典
      • locals()返回包含当前作用域内所有局部变量和值的字典

      创建:

      >>> a_dict = {'one':1,'two':2,'three':3}
      >>> a_dict
      {'one': 1, 'two': 2, 'three': 3}
      >>> keys = list('abcde')
      >>> values = list(range(4))
      >>> dictionary = dict(zip(keys,values))
      >>> dictionary
      {'a': 0, 'b': 1, 'c': 2, 'd': 3}
      >>> x = dict()
      >>> x          #空字典
      {}
      >>> d = dict(name='Dong', age=37)    #使用键值创建字典
      >>> d
      {'name': 'Dong', 'age': 37}
      >>> adict = dict.fromkeys(['name','age','sex'])   #给定内容创建字典,值为空
      >>> adict
      {'name': None, 'age': None, 'sex': None}
      

      读取:

      >>> a_dict = {'one':1,'two':2,'three':3}
      >>> a_dict['one']     #根据键获取值
      1
      >>> a_dict['name']
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      KeyError: 'name'
      

      使用字典对象的get方法获取指定键对应的值,并且可以在键不存在的时候返回指定值

      >>> a_dict.get('one')
      1
      >>> a_dict.get('name','None')  #如果不存在 返回给定值
      'None'
      

      使用字典对象的items()方法可以返回字典的键、值对

      使用字典对象的keys()方法可以返回字典的键

      使用字典对象的values()方法可以返回字典的值

      >>> for k,g in a_dict.items():  #序列解包 
      ...     print(k)
      ...     print(g)
      ...
      one
      1
      two
      2
      three
      3
      >>> a_dict.keys()
      dict_keys(['one', 'two', 'three'])
      

      添加,修改

      当以指定键为下标为字典赋值时:

      1)若键存在,则可以修改该键的值;

      2)若不存在,则表示添加一个键、值对。

      >>> a_dict
      {'one': 1, 'two': 2, 'three': 3}
      >>> a_dict['one'] = 11     #修改
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3}
      >>> a_dict['four'] = 4     #添加
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4}
      

      使用字典对象的update()方法将另一个字典的键、值对添加到当前字典对象。

      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4}
      >>> b_dict = {'five': 5}
      >>> a_dict.update(b_dict)  #将b_dict加到a_dict中
      >>> a_dict
      {'one': 11, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
      
      • 使用del删除字典中指定键的元素
      • 使用字典对象的clear()方法来删除字典中所有元素
      • 使用字典对象的pop()方法删除并返回指定键的元素
      • 使用字典对象的popitem()方法删除并返回字典中的一个元素

      字典推导式

      >>> s = {str(x):x for x in range(4)}
      >>> s
      {'0': 0, '1': 1, '2': 2, '3': 3}
      

      注意 : 字典的键是可以哈希的,且键都是唯一的。不能为可变元素,如:列表。

    集合

    • 集合是无序、可变序列,使用一对大括号界定,元素不可重复,同一个集合中每个元素都是唯一的。

    • 集合中只能包含数字、字符串、元组等不可变类型(或者说可哈希)的数据,而不能包含列表、字典、集合等可变类型的数据。

      简单说集合就是没有值的字典。

      >>> a = {3, 5}
      >>> a
      {3, 5}
      >>> a.add(4)
      >>> a
      {3, 4, 5}
      >>> a = {3,3,2,4,4}
      >>> a
      {2, 3, 4}
      >>> set(range(3,8))
      {3, 4, 5, 6, 7}
      >>> set()
      set()
      
      • 当不再使用某个集合时,可以使用

        del命令删除整个集合。集合对象的

        pop()方法弹出并删除其中一个元素

        remove()方法直接删除指定元素,

        clear()方法清空集合。

        >>> a = {1,2,3,4}
        >>> a.pop()
        1
        >>> a.pop()
        2
        >>> a
        {3, 4}
        >>> a.add(2)
        >>> a
        {2, 3, 4}
        >>> a.remove(3)
        >>> a
        {2, 4}
        >>> a.clear()
        >>> a
        set()
        >>> del a
        >>> a
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        NameError: name 'a' is not defined
        

        Python集合支持交集,并集,差集等运算

        >>> a_set = set(range(8,14))
        >>> b_set = set(range(9))
        >>> a_set | b_set						#并集
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
        >>> a_set.union(b_set)
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
        >>> a_set & b_set						#交集
        {8}
        >>> a_set.intersection(b_set)
        {8}
        >>> a_set - b_set						#差集
        {9, 10, 11, 12, 13}
        >>> a_set.difference(b_set)
        {9, 10, 11, 12, 13}
        >>> {3} & {4}
        set()
        >>> {3}.isdisjoint({4})                #如果两个集合的交集为空,返回True
        True
        >>> x^y								#对称差
        {3, 5}
        >>> x.symmetric_difference(y)
        {3, 5}
        

        子集,真子集,包含

        >>> x = {1, 2, 3}
        >>> y = {1, 2, 5}
        >>> z = {1, 2, 3, 4}
        >>> x.issubset(y)                      #测试是否为子集
        False
        >>> x.issubset(z)
        True
        >>> x < y                                #比较集合大小/包含关系
        False
        >>> x < z                                #真子集
        True
        >>> y < z
        False
        >>> {1, 2, 3} <= {1, 2, 3}               #子集
        True
        
    展开全文
  • 2、Python列表和元组

    2018-01-11 12:13:00
     Python中常用的序列结构有列表、元组、字典、字符串、集合等,字典和集合是无序的,其他三个都支持双向索引。一般0为第一个序列,但是python可以用负数做下标序列,最后一个下标为-1,之前的为-2,以此类推。 ...

    2、Python序列

      序列是一种数据存储方式,类似于C语言的数组。简单的说序列是一块用来存储多个值的连续内存空间,同一个序列的元素通常是相关的。

      Python中常用的序列结构有列表、元组、字典、字符串、集合等,字典和集合是无序的,其他三个都支持双向索引。一般0为第一个序列,但是python可以用负数做下标序列,最后一个下标为-1,之前的为-2,以此类推。

     

      2.1列表

        列表的所有元素放在一堆方括号中相邻元素之间用逗号分开,元素扩充或删除时,列表自动扩充或缩减,但尽量向列表末尾进行增删操作。同一列表中元素类型可以不同,可以是基本类型,也可以是序列类型。

        2.1.1列表的创建和删除

          创建:a_list=[]空列表

             a_list=['a','b','zxlc']

             也可以用list()函数将元组、range对象、字符串或其他类型的对象转换成列表例如:

             a_list=list((3,5,7,9))  #将元组转换成列表

             list(range(1,10,2)           #将range对象转换成列表(range函数:第一个参数是起始数,第二个参数是终止数,第三个数是步长)

             list('hello world')     #将字符串转换成列表

             x=list()          #创建空列表

           删除:del a_list

     

        2.1.2列表元素添加

          1、append()方法,在列表末尾添加一个元素

              a_list.append(i)

          2、+,创建一个新列表,在旧列表后加上这个新列表

            a_list=a_list+[i]

          3、extend()方法可以将其他元素放在后面

          4、insert()方法可以按元素顺序插入元素

          5、用乘法来扩展列表对象,将列表与整数相乘,生成一个新序列,新序列是之前序列的重复,相当于另外创建了一个序列(id不同)

     

        2.1.3列表元素删除

          1、使用del命令删除列表中的指定位置上的元素。

            a_list=[3,5,7,9,11]

            del a_list[1]

            a_list

            [3,7,9,11]

          2、pop()方法删除并返回指定位置上的元素(默认为最后一个),如果指定的索引超出了范围,就抛出异常。

          3、remove()方法删除首次出现的指定元素,如果列表中不存在这个元素,则抛出异常。

    ***每次执行完插入和删除操作,元素的索引都会改变

        2.1.4列表元素查询和计数

          查询可以直接用下标

          index()函数可以查看指定元素的索引

          count()函数可以计数某元素出现的次数

        2.1.5判断元素是否在列表中

          用in

            3 in a_list

        2.1.6切片操作

          切片使用两个冒号分隔的三个数字来完成:第一个数字为切片开始位置(默认为0);第二个数字为切片截止(但不包含)位置(默认为列表长度),第三个数字为切片的步长(默认为1),当步长省略时,最后一个冒号也可以省略

          例如 aList=[3,4,5,6,7,9,11,13,15,17]

           >>>aList[::-1]

             [17,15,13,11,9,7,6,5,4,3]

           >>>aList[::2]

             [3 ,5,7,11,15]

    用切片复制列表是一个中浅克隆,而直接列表等号赋值是深克隆。

        2.1.7列表排序

          利用sort()函数,返回排序后的原列表。

          默认为升序:aList.sort()

          改为降序:aList.sort(reverse=true)

     

          利用sorted()函数,返回排序后的新列表

        2.1.8列表中常用的方法

          1、cmp()比较大小

          2、len()返回列表长度

          3、max()、min()返回列表的最大最小值

          4、sum()返回列表值的和

          5、zip()将多个列表或元组对应位置的元素组合成为元组并返回包含这些元组的zip对象

            alist=[1,2,3]

            blist=[4,5,6]

            clist=[7,8,9]

            dlist=zip[alist,blist,clist]

            dlist

            [(1,4,7),(2,5,8),(3,6,9]

        2.1.9列表推导式

          >>>alist=[x*x for x in range(10)]

          相当于

          >>>alist=[]

          >>>for x in range(10):

              alist.append(x*x)

       2.2元组

        元组为不可变序列,元组一旦创建,用任何办法都无法修改其元素的值,也无法增加删除元素,确实需要修改则可以再创建一个元组。放在一对圆括号中。

        2.2.1元组创建

          a_tuple=('a','b')

          如果仅仅创建一个只有一个元素的元组,那么在这个元素后需要加一个逗号,不然会认为是该元素本身。

        2.2.2元组删除

          del()

        2.2.3元组和序列的区别

          1、元组不可变,所以不能有增删改元素;序列可变,有许多函数可以增删改元素

          2、元组通过tuple()函数可以冻结列表使其不可变;而列表通过list()函数可以融化元组,使其可变。

          不过元组中的元素可以包含可变的序列。

        2.2.4序列解包

        在元组中,可以用序列解包进行多变量同时赋值

        >>>x,y,z=1,2,3

        >>>print(x,y,z)

        在字典中,默认是对字典的键操作,如果需要对键值对操作,需要使用字典的items()方法,如果需要对字典的值操作,则需要使用字典的values()方法指定。

        >>>a=[1,2,3]

        >>>b,c,d=a

        >>>s={'a':1,'b':2,'c':3}

        >>>b,c,d=s.itmes()

        >>>b

        ('a',1)

        >>>b,c,d=s

        >>>b

        'a'

        >>>b,c,d=s.values()

        >>>print(b,c,d)

        1 3 2

        

        2.2.5生成器推导式

        用圆括号,返回为一个生成器对象,可以将其强转为一个列表或者一个元组,也可以使用生成器对象的_next_()方法进行遍历,或者直接将其作为迭代器对象来使用,不过只能访问一次,还想访问需要重新创建。

        >>>g=((i+2)**2 for i in range(10))

         这是个生成器对象,意为4,9,16.。。。,121

        >>>g.next()

        4

        >>>g.next()

        9

    转载于:https://www.cnblogs.com/television/p/8266952.html

    展开全文
  • 列表、元组、字符串等有序列以及range对象均支持双向索引 Python采用基于值的自动内存管理模式,变量并不直接存储值,而是存储值的引用或内存地址 同理,Python列表中的元素也是值的引用 尽量避免过多使用列表 ...

    3.1 列表

    • 列表、元组、字符串等有序列以及range对象均支持双向索引
    • Python采用基于值的自动内存管理模式,变量并不直接存储值,而是存储值的引用或内存地址
    • 同理,Python列表中的元素也是值的引用
    • 尽量避免过多使用列表

    3.1.1 列表创建与删除

    • 字典转换为列表
    print(list({'a':1,'b':2,'c':3}))
    print(list({'a':1,'b':2,'c':3}.items())  #?????????????????????
    
      File "<ipython-input-7-7fbf2c454f11>", line 2
        print(list({'a':1,'b':2,'c':3}.items())  #?????????????????????
                                                                       ^
    SyntaxError: unexpected EOF while parsing
    
    x = [1,2,3]
    del x  #del命令适用于所有类型的Python对象
    print(x)
    
    ---------------------------------------------------------------------------
    
    NameError                                 Traceback (most recent call last)
    
    <ipython-input-9-e84abb2c7240> in <module>
          1 x = [1,2,3]
          2 del x  #del命令适用于所有类型的Python对象
    ----> 3 print(x)
    
    
    NameError: name 'x' is not defined
    

    3.1.2 列表元素访问

    • 0为第一个元素,-1为最后一个元素

    3.1.3 列表常用方法

    • append()、insert()、extend() 添加功能
      • append() :在尾部追加一个元素
      • insert() :在任意指定位置插入一个元素
      • entend() :将另一列表中所有元素追加至当前列表尾部
      • 以上三种操作都属于原地操作,不影响列表对象在内存中的起始地址
    x = [1,2,3]
    print(id(x))
    x.append(3)
    x.insert(0,0)
    x.extend([5,6,7])
    print(x)
    print(id(x))  #列表在内存中的地址不变
    
    2911215587272
    [0, 1, 2, 3, 3, 5, 6, 7]
    2911215587272
    
    • pop()、remove()、clear() 删除功能
      • pop() :用于删除并返回指定位置(默认是最后一个)上的元素,若指定的位置不是合法的索引则抛出异常
      • remove() :用于删除列表中第一个值与指定值相等的元素,若列表中不存在该元素则抛出异常
      • clear() :用于清空列表中所有元素 与del区别
      • 以上三种同为原地操作
    x = [1,2,3,4,5]
    x.remove(2)
    print(x)
    del x[3]
    print(x)
    x.clear()
    print(x)
    
    [1, 3, 4, 5]
    [1, 3, 4]
    []
    
    • count()、index()
      • count() :用于返回列表中指定元素出现的次数
      • index() :用于返回指定元素在列表中首次出现的位置,若元素不在列表中则抛出异常
    x = [1,2,2,3,3,3,4,4,4,4]
    print(x.count(3))
    print(x.index(2))
    print(x.index(5))  #不存在 异常
    
    3
    1
    
    
    
    ---------------------------------------------------------------------------
    
    ValueError                                Traceback (most recent call last)
    
    <ipython-input-15-c9eb6993be8e> in <module>
          2 print(x.count(3))
          3 print(x.index(2))
    ----> 4 print(x.index(5))  #不存在 异常
    
    
    ValueError: 5 is not in list
    
    • 下面的代码使用异常处理结构保证用户输入的是三位数,然后使用关键字in来测试用户输入的数字是否在列表中,若果存在则输出其索引,否则提示不存在
    from random import sample
    lst = sample(range(100,1000),100)
    while True:
        x = input('请输入一个三位数:')
        try:
            assert len(x) == 3,'长度必须为3'
            x = int(x)
            break
        except:
            pass
    if x in lst:
        print('元素{0}在列表中的索引为:{1}'.format(x,lst.index(x)))
    else:
        print('列表中不存在该元素。')
    
    • sort()、reverse()

      • sort() :按照指定的规则对所有元素进行排序,默认规则为升序False
      • reverse() :用于将列表所有元素逆序或翻转
      • 两者均为原地操作
    • sorted()、reversed()

      • 返回新列表
    • copy()

      • 返回列表的浅复制
      • 详情见下
    x = [1,2,[3,4,5]]
    y = x.copy()
    print(y)
    y[0] = 7  #改变y中第一个元素,x不受影响
    print(y)
    print(x)
    y[2].append(6)  #此过程会改变x中的元素
    print(y)
    print(x)
    
    [1, 2, [3, 4, 5]]
    [7, 2, [3, 4, 5]]
    [1, 2, [3, 4, 5]]
    [7, 2, [3, 4, 5, 6]]
    [1, 2, [3, 4, 5, 6]]
    
    • 标准库copy中的deepcopy()函数实现深复制
    • 深复制,是指对原列表中的元素进行递归,把所有的值都复制到新列表中,对嵌套的子列表不再是复制引用
    from copy import deepcopy
    x = [1,2,[3,4,5]]
    y = deepcopy(x)
    print(y)
    y[2].append(6)  #深拷贝,对x不产生影响
    print(y)
    print(x)
    
    [1, 2, [3, 4, 5]]
    [1, 2, [3, 4, 5, 6]]
    [1, 2, [3, 4, 5]]
    
    • 然而,如果使用赋值操作,则对其中一个做的任何修改都会影响另一个变量
    x = [1,2,[3,4]]
    y = x
    y[0] = 6
    y[2].append(5)
    print(y)
    print(x)
    
    [6, 2, [3, 4, 5]]
    [6, 2, [3, 4, 5]]
    

    3.1.4 列表对象支持的运算符

    • 加法运算符 :非原地操作 返回新列表 效率低
    • 复合赋值运算符+= :原地操作 与append()一样 高效
    x = [1,2,3]
    print(id(x))
    x = x + [4]
    print(x)
    print(id(x))
    x += [5]
    print(x)
    print(id(x))
    
    1151602854088
    [1, 2, 3, 4]
    1151603561160
    [1, 2, 3, 4, 5]
    1151603561160
    
    • 乘法运算符 :用于列表和整数相乘,表示序列重复 返回新列表
    • 复合赋值运算符*= :原地操作

    3.1.5 内置函数对列表的操作(详见p51)

    • all()函数用来测试列表中是否所有元素都等价于True
    • any()函数用来测试列表中是否有等价于True的元素
    import random
    x = list(random.randint(0,5) for i in range(10))
    print(x)
    print(all(x))
    print(any(x))
    
    [1, 2, 2, 0, 4, 1, 3, 3, 5, 2]
    False
    True
    

    3.1.6 列表推导式语法与应用案例

    • 语法形式:

      • [expression for expr1 in sequence1 if condition1
      • expression for expr2 in sequence1 if condition2
      • expression for exprN in sequence1 if conditionN]
    • 公比为2的等比数列的前64项和

    print(sum([2**i for i in range(64)]))
    
    18446744073709551615
    
    • 嵌套列表的平铺
    vet = [[1,2,3],[4,5,6],[7,8,9]]
    print([num for elem in vet for num in elem])
    
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    • 过滤不符合条件的元素
    import random
    alist = [random.randint(-10,10) for i in range(10)]  #选择符合条件的元素组成新的列表
    print(alist)
    print(list(a for a in alist if a > 3))
    
    [5, -3, 10, 10, -2, 0, -3, -1, -2, -7]
    [5, 10, 10]
    
    from random import randint
    x = [randint(1,10) for i in range(20)]  #20个介于[1,10]的整数
    print(x)
    m = max(x)
    print(m)
    blist = [index for index,value in enumerate(x) if value == m]  #最大整数的所有出现的位置
    print(blist)
    
    [10, 8, 7, 8, 1, 6, 7, 5, 2, 7, 10, 8, 5, 4, 10, 2, 9, 7, 9, 4]
    10
    [0, 10, 14]
    
    • 同时遍历多个列表或可迭代对象
    [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
    
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
    
    [(x,y) for x in [1,2,3] if x == 1 for y in [3,1,4] if y != x]
    
    [(1, 3), (1, 4)]
    
    l1 = [1,2,3]
    l2 = [4,5,6]
    [l1[i] + l2[i] for i in range(len(l1))]  #相同位置的元素相加
    
    [5, 7, 9]
    
    • 矩阵转置
    a = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
    b = [[ele[i] for ele in a] for i in range(4)]
    print(b)
    
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
    
    list(map(list,zip(*a)))
    
    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
    

    3.1.7 切片操作 (不会因为下标越界而抛出异常)

    • 使用切片获取列表的部分元素
    alist = [3,4,5,6,7,9,11,13,15,17]
    print(alist[::])  #[start:end:step]  默认值分别为0、列表长度、1
    print(alist[0:100])  #切片结束位置大于列表长度时,从列表尾部截断
    print(alist[100:])  #切片开始位置大于列表长度时,返回空列表
    print(alist[100:-5:-1])
    
    [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
    [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
    []
    [17, 15, 13, 11]
    
    • 使用切片为列表增加元素(原地操作)
    alist = [3,5,7]
    alist[len(alist):] = [9]  #在列表末尾
    alist[:0] = [1,2]  #在列表头部
    alist[3:3] = [4]  #在列表中间
    alist
    
    [1, 2, 3, 4, 5, 7, 9]
    
    • 使用切片替换和修改列表中的元素
    alist = [3,5,7,9]
    alist[:3] = [1,2,3]  #替换列表元素,等号两边的列表长度相等(可不相等)
    print(alist)
    alist[3:] = [4,5,6]  #切片连续,等号两边的长度可以不相等
    print(alist)
    alist[::2] = [0]*3  #隔一个修改一个
    print(alist)
    alist[::2] = ['a','b','c']  #隔一个修改一个
    print(alist)
    alist[::2] = [1]  #切片不连续时等号两边列表的长度必须相等
    
    [1, 2, 3, 9]
    [1, 2, 3, 4, 5, 6]
    [0, 2, 0, 4, 0, 6]
    ['a', 2, 'b', 4, 'c', 6]
    
    
    
    ---------------------------------------------------------------------------
    
    ValueError                                Traceback (most recent call last)
    
    <ipython-input-29-7ebb8c00bd6f> in <module>
          8 alist[::2] = ['a','b','c']  #隔一个修改一个
          9 print(alist)
    ---> 10 alist[::2] = [1]  #切片不连续时等号两边列表的长度必须相等
    
    
    ValueError: attempt to assign sequence of size 1 to extended slice of size 3
    
    • 使用切片删除列表中的元素
    alist = [3,5,7,9]
    alist[:3] = []  #删除列表中前三个元素
    alist
    
    [9]
    
    • 使用del命令与切片结合来删除
    alist = [3,5,7,9,11]
    del alist[::2]  #切片元素可不连续
    alist
    
    [5, 9]
    
    • 切片得到的是列表的浅复制(详见p59)
    展开全文
  • Python序列概述 ...§ 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 Python序列分类示意图 ​   2.1 ...

    Python序列概述

    § Python序列类似于其他语言中的数组,但功能要强大很多。

    § Python中常用的序列结构有列表、元组、字符串,字典、集合以及range等对象也支持很多类似的操作。

    § 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。

    Python序列分类示意图

     

    2.1  列表

    2.1.1  定义

    列表是Python中内置有序可变序列,列表的所有元素放在一对中括号[]”中,并使用逗号分隔开;

    一个列表中的数据类型可以各不相同,可以同时分别为整数、实数、字符串等基本类型,甚至是列表、元组、字典、集合以及其他自定义类型的对象。

    例如:

    [1,2,3,2.4,5]

    [0.01,"abc",[1,2,3],(2,1,3,4,7),{5:6}]


    常用的列表对象方法

     

    2.1.2  列表的创建与删除

    创建

    ①使用“=”直接将一个列表赋值给变量即可创建列表对象。例如:a_list = [],b_list = [1,2,3]

    使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

    例如:a_list = list("Hello")   将字符串 "hello"  转换成列表 ['H','e','l','l','o']

    删除

    当不再使用时,使用del命令删除整个列表

    例如:

    >>>x =[1,2,3]

    >>>del  x[1]                    #删除指定位置元素

    >>>x

    [1,3]

    >>>del x                        #删除整个列表

    >>>x

    Traceback (most recent call last):

      File "<pyshell#6>", line 1, in <module>

          x

    NameError: name 'x' is not defined

     2.1.2  列表元素的增加

    append()

    向列表尾部追加一个元素,不改变其内存首地址,属于原地操作。

    例如:

    >>>x = [1,2,3]

    >>>x.append(4)

    >>>x

    [1,2,3,4]

    insert() 

    向列表任意位置插入一个元素,不改变其内存首地址,属于原地操作。

    例如:

    >>>x = [1,3,4]

    >>>x.insert(1,2)

    >>>x

    [1,2,3,4]

    extend() 

    将另一个迭代对象的所有元素添加至该列表对象尾部,不改变其内存首地址,属于原地操作。

    例如:

    >>>x = [1,2]

    >>>x.extend([3,4])

    >>>x

    [1,2,3,4]

    运算符" + " 和" * "

    并不是真的为列表添加元素,而是创建一个新列表,不属于原地操作,而是返回新列表。

     >>> x = [1,2,3]

    >>>x = x + [4]

    >>>x

    [1,2,3,4]

    >>>x = x*2

    >>>x

    [1,2,3,4,1,2,3,4]

      2.1.3  列表元素的删除

    pop()

    使用列表的pop()方法删除并返回指定(默认为最后一个)位置上的元素,如果给定的索引超出了列表的范围则抛出异常。

    例如:

    >>>x = [1,2,3,4]

    >>>x.pop()                        #弹出并返回尾部元素

    4

    >>>x.pop(1)                     #弹出并返回指定位置的元素

    >>>2

     remove()

    删除首次出现的指定元素,如果列表中不存在要删除的元素,则抛出异常。

    例如:

    >>>x = [1,2,2,3,4]

    >>>x.remove(2)

    >>>x

    [1,2,3,4]

    clear()

    清空列表。

    例如:

    >>>x = [1,2,3,4]

    >>>x.clear()

    >>>x

    [ ]

    del 

    删除列表中的指定位置上的元素。

    例如:

    >>>x = [1,2,3,4]

    >>>del x[1]

    >>>x

    [1,3,4]

    2.1.4 列表元素访问与计数

    count()

    统计指定元素在列表对象中出现的次数。

    例如:

    >>> x =[1,2,3,3,4,5]

    >>>x.count(3)

    2

    >>>x.count(0)

    0

    index() 

    获取指定元素首次出现的下标,若列表对象中不存在指定元素,则抛出异常。

    例如:

    >>>x = [1,2,3,2,2,4]

    >>>x.index(2)

    1

    in 

    测试列表中是否存在某元素

    例如:

    >>>x = [1,2,3,4]

    >>>3 in x

    True

    >>>5 in x

    False

     2.1.5 列表排序

    sort()

    按照指定规则对所有元素进行排序,默认规则是直接比较规则大小。

    例如:

    >>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

    >>> import random

    >>> random.shuffle(aList)                              #随机降序

    >>> aList

    [3, 4, 15, 11, 9, 17, 13, 6, 7, 5]

    >>> aList.sort()                                              #默认是升序排序

    >>> aList.sort(reverse = True)                       #降序排序

    >>> aList

    [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

    >>> aList.sort(key = lambda x:len(str(x)))      #按转换成字符串的长度排序

    >>> aList

    [9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

    reverse() 

    将列表中所有元素原地逆序排列。

    例如:

    >>>x = [1,3,2,4,6,5]

    >>>x.reverse()

    >>>x

    [5,6,4,2,3,1]

     sorted()

    使用内置函数sorted对列表进行排序并返回新列表,不对原列表做任何修改。

    例如:

    >>>x = [6,4,2,4,1]

    >>> sorted(x)                                     #升序排序

    [1,2,4,4,6]

    >>> sorted(aList,reverse = True)             #降序排序

    [6,4,4,2,1]

    >>>x

    [6,4,2,4,1]

    reversed() 

    返回一个逆序排列后的迭代对象,不对原列表做任何修改。

    >>>x =[1,5,3,6,2]

    >>>list(reversed(x))

    [2,6,3,5,1]

    >>>x

    [1,5,3,6,2]

    2.1.6  切片操作
    使用切片获取列表中的元素

    >>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

    >>> aList[::]                                                #返回包含元素的新列表

    [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

    >>> aList[::-1]                                             #逆序的所有元素

    [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

    >>> aList[::2]                                               #偶数位置,隔一个取一个

    [3, 5, 7, 11, 15]

    >>> aList[1::2]                                             #奇数位置,隔一个取一个

    [4, 6, 9, 13, 17]

    >>> aList[3::]                                               #从下标3开始的所有元素

    [6, 7, 9, 11, 13, 15, 17]

    >>> aList[3:6]                                              #下标在[3, 6)之间的所有元素

    [6, 7, 9]

    >>> aList[0:100:1]                                       #100个元素,自动截断

    [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

    >>> a[100:]                                                  #下标100之后的所有元素,自动截断

    []

    >>> x[100]                                                   #直接使用下标访问会发生越界

    IndexError: list index out of range

    使用切片来原地修改列表内容

    >>> aList = [3, 5, 7]

    >>> aList[len(aList):] = [9]               #在尾部追加元素

    >>> aList

    [3, 5, 7, 9]

    >>> aList[:3] = [1, 2, 3]                  #替换前3个元素

    >>> aList

    [1, 2, 3, 9]

    >>> aList[:3] = []                         #删除前3个元素

    >>> aList

    [9]

    >>> aList = list(range(10))

    >>> aList

    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    >>> aList[::2] = [0]*5                     #替换偶数位置上的元素

    >>> aList

    [0, 1, 0, 3, 0, 5, 0, 7, 0, 9]

    >>> aList[::2] = [0]*3                     #切片不连续,两个元素个数必须一样多

    ValueError: attempt to assign sequence of size 3 to extended slice of size 5

    使用del与切片结合来删除列表元素 

    >>> aList = [3,5,7,9,11]

    >>> del aList[:3]                          #删除前3个元素

    >>> aList

    [9, 11]

     

    >>> aList = [3,5,7,9,11]

    >>> del aList[::2]                         #删除偶数位置上的元素

    >>> aList

    [5, 9]

     切片返回的是列表元素的浅复制

    所谓浅复制,是指生成一个新的列表,并且把原列表中所有元素的引用都复制到新列表中

    例如:

     

    >>> aList = [3, 5, 7]

    >>> bList = aList              #bList与aList指向同一个内存

    >>> bList

    [3, 5, 7]

    >>> bList[1] = 8                #修改其中一个对象会影响另一个

    >>> aList

    [3, 8, 7]

    >>> aList == bList             #两个列表的元素完全一样

    True

    >>> aList is bList              #两个列表是同一个对象

    True

    >>> id(aList)                     #内存地址相同

    19061816

    >>> id(bList)

    19061816

    >>> aList = [3, 5, 7]

    >>> bList = aList[::]                 #切片,浅复制

    >>> aList == bList                    #两个列表的元素完全一样

    True

    >>> aList is bList                    #但不是同一个对象

    False

    >>> id(aList) == id(bList)            #内存地址不一样

    False

    >>> bList[1] = 8                      #修改其中一个不会影响另一个

    >>> bList

    [3, 8, 7]

    >>> aList

    [3, 5, 7]

     2.1.7  用于序列操作的常用内置函数

    len()

    返回列表中的元素个数,同样适用于元组、字典、集合、字符串等。

    max()min()

    返回列表中的最大或最小元素,同样适用于元组、字典、集合、range对象等。

    sum()

    对列表的元素进行求和运算。

    zip()

    返回可迭代的zip对象。

    例如:

    >>> aList = [1, 2, 3]

    >>> bList = [4, 5, 6]

    >>> cList = zip(a, b)                               #返回zip对象

    >>> cList

    <zip object at 0x0000000003728908>

    >>> list(cList)                                         #zip对象转换成列表

    [(1, 4), (2, 5), (3, 6)]

     enumerate()

    枚举列表元素,返回枚举对象,其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

    例如: 

    >>> for item in enumerate('abcdef'):

    print(item)

     

    (0, 'a')

    (1, 'b')

    (2, 'c')

    (3, 'd')

    (4, 'e')

            (5, 'f')

    2.1.8  列表推导式 

    列表推导式使用非常简洁的方式来快速生成满足特定需求的列表,代码具有非常强的可读性。

    语法形式:[表达式  for  变量 in 序列或迭代对象]

     列表推导式在逻辑上相当于一个循环,只是形式更加简洁。

    ①使用列表推导式实现嵌套列表的平铺

    >>> vec = [[1,2,3], [4,5,6], [7,8,9]]

    >>> [num for elem in vec for num in elem]

    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    相当于:

    >>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    >>> result = []

    >>> for elem in vec:

        for num in elem:

      result.append(num)

    >>> result

    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    ②过滤不符合条件的元素

    从列表中选择符合条件的元素组成新的列表

    >>> aList = [-1,-4,6,7.5,-2.3,9,-11]

    >>> [i for i in aList if i>0]

    [6, 7.5, 9]

    列出当前文件夹下所有Python源文件:

    >>> import os

    >>> [filename for filename in os.listdir('.') if filename.endswith(('.py', '.pyw'))]

    在列表推导式中使用多个循环,实现多序列元素的任意组合,并且可以结合条件语句过滤特定元素

    >>> [(x, y) for x in range(3) for y in range(3)]

    [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

    >>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    使用列表推导式实现矩阵转置

    >>>matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

    >>> [[row[i] for row in matrix] for i in range(4)]

    [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

    也可以使用内置函数来实现矩阵转置:

    >>>list(zip(*matrix))                 #序列解包

     [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

     

    列表推导式中可以使用函数或复杂表达式

    >>> def f(v):

        if v%2 == 0:

            v = v**2

        else:

            v = v+1

        return v

    >>> [f(v) for v in [2, 3, 4, -1] if v>0]

    [4, 4, 16]

    >>> [v**2 if v%2 == 0 else v+1 for v in [2, 3, 4, -1] if v>0]

    [4, 4, 16]

    列表推导式支持文件对象迭代

    >>>fp = open('C:\install.log','r')

    >>>print([line for line in fp])

    >>>fp.close()

    ⑦ 使用列表推导式生成100以内的所有素数

    >>> [p for p in range(2, 100) if 0 not in [p%d for d in range(2, int(p**0.5)+1)]]

    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

     2.1.9  使用列表实现向量运算

    >>> import random

    >>> x = [random.randint(1,100) for i in range(10)] #生成随机数

    >>> list(map(lambda i: i+5, x))                               #所有元素同时加5

    >>> x = [random.randint(1,10) for i in range(10)]

    >>> y = [random.randint(1,10) for i in range(10)]

    >>> import operator

    >>> sum(map(operator.mul, x, y))             #向量内积

    >>> sum((i*j for i, j in zip(x, y)))                 #向量内积

    >>> list(map(operator.add, x, y))               #两个等长的向量对应元素相加

    PS:

    本篇主要参考董付国老师的《Python可以这样学》一书,这是一本不错的Python入门书籍,有兴趣的可以买本看看,当然,也可以持续关注我的博客,我会一直更新相关内容的。 

    展开全文
  • 除了字典和集合属于无序序列之外,列表、元组、字符串等序列都支持双向索引。 注意,序列的第一个元素下标都是“0”。(和C语言中数组一样) 还有,就是Python竟然可以用“负数”作为序列下标!最后一个元素下标为...
  • 有序序列:列表、元组、字符串,支持双向索引(第一个元素下标为0,最后一个元素下标为-1) 不可变序列:字符串、元组 可变序列:列表、集合、字典 列表 尽量从列表尾增加或删除元素,可以大幅度提高处理速度 ...
  • Python元组与列表的异同点详解

    千次阅读 2020-03-15 21:05:47
    支持使用双向索引访问其中的元素; 以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引,len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。 不同点: ...
  • 列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index(...
  • 支持双向索引,索引范围 [ -L, L-1 ] ,L – 表示列表、元组和字符串的长度(分正向索引和反向索引)。 正向索引:0 表示第 1 个元素,1 表示第 2 个元素,2 表示第 3 个元素… 一、列表: 放在一对方括号...
  • 一、列表 1、创建列表 方式一,用中括号[]直接定义。例如:x=[1,2,3,4,5,6] 方式二,用list()将元组、字符...Python支持双向索引,即除了常见的用正整数做下标,还可以用负整数做下标,[-1]表示最后一个元素,[-2]表...
  • 若列表中某元素存在则返回之 任务:  你有一个列表L,还有一个索引号i,若i...列表支持双向索引,所以i可以为负数 >>> def list_get(L,i,v=None): if -len(L)<= i < len(L): return L[i...
  • ​本章引言 ...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 定义列表 语法:list1=[元素1...
  • python2.0

    2021-03-21 17:10:44
    1.索引:除字典和集合属于无序序列外,列表,元组,字符串,等序列类型均支持双向索引。 2。本章主要介绍几种基本数据类型的用法,以及通过实际应用来介绍列表的推导式,切片操作和生成器的推导式。 3.列表python的...
  • 灵活高效的序列,最能体现python特点的部分 # 2 python序列 #序列的下标从0开始,支持双向索引,最右边为-1,既len(x)-1 # 2.1列表 #一对[]中,可以修改 # 2.1.1 列表的创建与删...
  • python自学笔记

    2020-03-14 00:26:37
    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推,最后一个元素小标为-1,倒数第二个元素下标为-2, 列表 列表python中内置有序、可变序列,列表的所有元素放在一对中括号 ...
  • 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 1.1列表 列表Python中内置有序可变序列,列表中所...
  • python学习心得

    2021-03-28 22:48:47
    列表,字符串,元祖属于有序序列,支持双向索引,支持使用附属数作为下标来访问其中的元素,-1表示最后一个元素位置,-2表示倒数第二个元素位置。 在Python中,同一个列表中元素的数据类型可以各不相同,可以同时...
  • Python学习笔记2

    2021-03-23 13:41:25
    列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 列表的创建与删除 创建列表 创建列表之后,可以使用整数作为...
  • Python第二章

    2021-03-21 20:36:00
    除字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;如果使用复数作为索引,则最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推...
  • 序列是一块用来存放多个值的内存空间,Python中常用的序列结构有列表、元组、字典、字符串、集合等,除字典和集合属于无序序列之外,列表、元组、字符串等类型都支持双向索引。 2.分类 2.1 列表 定义:列表是...
  • Python3常用数据结构

    2020-03-28 18:16:44
    Python3中有三种组合...支持双向索引。第一个元素为0,最后一个元素为-1 列表 内置可变序列,所有元素放在一对中括号中,并用逗号分隔。当列表元素增加或者删除时,列表对象自动进行扩展或者收缩内存,保证元素之...
  • 第2章 Python序列

    2018-03-06 19:40:00
    Python序列类似于C或Basic中的一维、多维数组等,但功能要强大很多,使用也更加灵活、方便,...列表、元组、字符串等序列类型以及range对象均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推。可以...
  • Python入门基础(2)

    2021-05-18 12:01:45
    Python入门欢迎来到梁老湿课堂Python序列的概述多练多学多坚持,我们下期...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此
  • Python学习日志20.3.14

    2020-03-14 23:43:41
    除了dict和set外,其他均支持双向索引 2、列表方法 list.append(x) 将元素x添加到列表尾部 list.extend(L) 将列表L中所有元素添加至列表尾部 list.insert(index,x) 在列表指定位置index处添加元素x list.remove(x) ...
  • python入门基础(三)

    2020-07-24 14:34:12
    列表元组字符串支持双向索引 第一个元素下标为0 第二个元素下标为1 以此类推最后一个元素下标为-1 列表元素的增加 列表元素的删除 这里是有点不好理解的地方 当我们换个数据再看 列表元素访问与计数 切片...
  • 列表和元组都属于有序序列,都支持使用双向索引访问其中元素 支持count()、index()、len()、map()、filter()等内置函数 支持+、*、+=、in等运算符 不同: 元组属于不可变序列,不可以直接修改元组中元素的值,也...
  • awesome-python 是 vinta 发起维护的 Python 资源列表,内容包括:Web 框架、网络爬虫、网络内容提取、模板引擎、数据库、数据可视化、图片处理、文本处理、自然语言处理、机器学习、日志、代码分析等。由「开源前哨...
  • Python一周小记(六)

    2021-05-05 18:58:58
    列表,元组,字符串是有序序列,支持双向索引(从左往右查找[ 1: ],从右往左查找([ :-1]) 列表的一些要点 列表中元素的类型 同一个列表中元素的类型可以不相同,可以同时包含整数、实数、字符串、等基本类型,也...
  • 除字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下表为1,以此类推;如果使用负数作为索引,则最后一个元素下表为-1,倒数第二个元素下表为-2...
  • collections模块中的deque双端队列结构collection.deque()代码 collection.deque() ...deque是为了高效实现插入和删除操作的双向列表,适合用于队列和栈。 deque除了实现list的append()和pop()外,还支持...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

python列表支持双向索引

python 订阅