精华内容
下载资源
问答
  • Python元组与列表的异同点详解

    千次阅读 2020-03-15 21:05:47
    支持使用双向索引访问其中的元素; 以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引,len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。 不同点: ...

    Python元组与列表的异同点

    相同点:
    1. 列表和元组都属于有序序列;
    2. 都支持使用双向索引访问其中的元素;
    3. 以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引,len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。
    不同点:
    1. 元组属于不可变序列,不可以直接修改元组中元素的值,也无法为元组增加或删除元素。
    >>> x = (1, 2, 3)       #直接把元组赋值给一个变量
    >>> x[1] = 4            #元组是不可变的
    TypeError: 'tuple' object does not support item assignment
    
    1. 元组没有提供append()、extend()和insert()等方法,无法向元组中添加元素;同样,元组也没有remove()和pop()方法,也不支持对元组元素进行del操作,不能从元组中删除元素,而只能使用del命令删除整个元组。
    2. 元组也支持切片操作,但是只能通过切片来访问元组中的元素,而不允许使用切片来修改元组中元素的值,也不支持使用切片操作来为元组增加或删除元素。
    3. 元组缓存于Python运行时环境,每次使用元组时无须访问内核去分配内存。
    4. Python的内部实现对元组做了大量优化,访问速度比列表更快。如果定义了一系列常量值,主要用途仅是对它们进行遍历或其他类似用途,而不需要对其元素进行任何修改,那么一般建议使用元组而不用列表。
    5. 元组在内部实现上不允许修改其元素值,从而使得代码更加安全,例如调用函数时使用元组传递参数可以防止在函数中修改元组,而使用列表则很难保证这一点。
    6. 元组可用作字典的键,也可以作为集合的元素。而列表则永远都不能当作字典键使用,也不能作为集合中的元素。

    Python元组与列表详解

    传送门:Python列表详解
    传送门:Python元组详解

    展开全文
  • 列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index(...

    列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引。虽然有着一定的相似之处,但列表和元组在本质上和内部实现上都有着很大的不同。

    元组属于不可变(immutable)序列,一旦创建,不允许修改元组中元素的值,也无法为元组增加或删除元素。因此,元组没有提供append()、extend()和insert()等方法,无法向元组中添加元素;同样,元组也没有remove()和pop()方法,也不支持对元组元素进行del操作,不能从元组中删除元素。元组也支持切片操作,但是只能通过切片来访问元组中的元素,而不允许使用切片来修改元组中元素的值,也不支持使用切片操作来为元组增加或删除元素。从一定程度上讲,可以认为元组是轻量级的列表,或者“常量列表”。

    Python的内部实现对元组做了大量优化,访问速度比列表更快。如果定义了一系列常量值,主要用途仅是对它们进行遍历或其他类似用途,而不需要对其元素进行任何修改,那么一般建议使用元组而不用列表。元组在内部实现上不允许修改其元素值,从而使得代码更加安全,例如调用函数时使用元组传递参数可以防止在函数中修改元组,而使用列表则很难做到这一点。

    最后,作为不可变序列,与整数、字符串一样,元组可用作字典的键,也可以作为集合的元素,而列表则永远都不能当做字典键使用,也不能作为集合中的元素,因为列表不是不可变的,或者说不可哈希。

    展开全文
  • 列表、元组、字符串支持双向索引,第一个元素下标为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

    展开全文
  • 列表和元组都属于有序序列,都支持使用双向索引访问其中元素 支持count()、index()、len()、map()、filter()等内置函数 支持+、*、+=、in等运算符 不同: 元组属于不可变序列,不可以直接修改元组中元素的值,也...
  • 除了字典和集合属于无序序列之外,列表、元组、字符串等序列都支持双向索引。 注意,序列的第一个元素下标都是“0”。(和C语言中数组一样) 还有,就是Python竟然可以用“负数”作为序列下标!最后一个元素下标为...
  • 支持双向索引,索引范围 [ -L, L-1 ] ,L – 表示列表、元组和字符串的长度(分正向索引和反向索引)。 正向索引:0 表示第 1 个元素,1 表示第 2 个元素,2 表示第 3 个元素… 一、列表: 放在一对方括号...
  • ​本章引言 ...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 定义列表 语法:list1=[元素1...
  • 一、列表 1、创建列表 方式一,用中括号[]直接定义。例如:x=[1,2,3,4,5,6] 方式二,用list()将元组、字符...Python支持双向索引,即除了常见的用正整数做下标,还可以用负整数做下标,[-1]表示最后一个元素,[-2]表...
  • Python序列概述 ...§ 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 Python序列分类示意图 ​   2.1 ...
  • python自学笔记

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

    2021-03-21 17:10:44
    1.索引:除字典和集合属于无序序列外,列表,元组,字符串,等序列类型均支持双向索引。 2。本章主要介绍几种基本数据类型的用法,以及通过实际应用来介绍列表的推导式,切片操作和生成器的推导式。 3.列表是python的...
  • Python学习笔记2

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

    2020-07-24 14:34:12
    列表元组字符串支持双向索引 第一个元素下标为0 第二个元素下标为1 以此类推最后一个元素下标为-1 列表元素的增加 列表元素的删除 这里是有点不好理解的地方 当我们换个数据再看 列表元素访问与计数 切片...
  • Python入门基础(2)

    2021-05-18 12:01:45
    Python入门欢迎来到梁老湿课堂Python序列的概述多练多学多坚持,我们下期...列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此
  • 列表、元组、字符串等有序列以及range对象均支持双向索引 Python采用基于值的自动内存管理模式,变量并不直接存储值,而是存储值的引用或内存地址 同理,Python列表中的元素也是值的引用 尽量避免过多使用列表 ...
  • python学习心得

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

    2021-03-21 20:36:00
    除字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;如果使用复数作为索引,则最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推...
  • 第2章 Python序列

    2018-03-06 19:40:00
    Python序列类似于C或Basic中的一维、多维数组等,但功能要强大很多,使用也更加灵活、方便,...列表、元组、字符串等序列类型以及range对象均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推。可以...
  • 序列是一块用来存放多个值的内存空间,Python中常用的序列结构有列表、元组、字典、字符串、集合等,除字典和集合属于无序序列之外,列表、元组、字符串等类型都支持双向索引。 2.分类 2.1 列表 定义:列表是...
  • 有序序列:列表、元组、字符串,支持双向索引(第一个元素下标为0,最后一个元素下标为-1) 不可变序列:字符串、元组 可变序列:列表、集合、字典 列表 尽量从列表尾增加或删除元素,可以大幅度提高处理速度 ...
  • Python3常用数据结构

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

    2021-05-05 18:58:58
    列表,元组,字符串是有序序列,支持双向索引(从左往右查找[ 1: ],从右往左查找([ :-1]) 列表的一些要点 列表中元素的类型 同一个列表中元素的类型可以不相同,可以同时包含整数、实数、字符串、等基本类型,也...
  • 除字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下表为1,以此类推;如果使用负数作为索引,则最后一个元素下表为-1,倒数第二个元素下表为-2...
  • 常见概念梳理 ...列表、元组、字符串支持双向索引,字典支持使用"键"作为下标、集合不支持任何索引 关键字in可以用于列表和其它可迭代对象,包括元组、字典、range、字符串、集合 Python中的for循...
  • 2021-03-21

    2021-03-21 21:06:27
    ③列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推。 列表list 用中括号“[ ]”表示 1.任意对象的有序集合 列表是一组...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

python元组支持双向索引

python 订阅