精华内容
下载资源
问答
  • 列表和元组形式上的区别
    千次阅读
    2022-05-31 17:06:30

    目录

    一.list(列表)和tuple(元组)共同点和区别

    二.定义一个变量,包含现在所学的数据类型

    三.目前学到的序列有哪些?

    1.将除tuple之外的序列转换为tuple

    2.将除list之外的序列转换为list

    四.tuple中有哪些操作方法

    五.list中有哪些操作方法


    一.list(列表)和tuple(元组)共同点和区别

    共同点:都是一种序列的形式,可以储存不同类型的数据

    区别:1.列表是动态数组,它们可变且可以重设长度(改变其内部元素的个数)。

            2. 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。

    二.定义一个变量,包含现在所学的数据类型

    list_data = [1, 1.2, b'123', True, None, 1+2j, 'az', (6, 6, 6), [1, 2]]
    print(list_data, type(list_data))

    输出:

    [1, 1.2, b'123', True, None, (1+2j), 'az', (6, 6, 6), [1, 2]] <class 'list'>

    三.目前学到的序列有哪些?

    字符串str;字节bytes;元组tuple;列表list

    1.将除tuple之外的序列转换为tuple

    str_data = 'az'
    bytes_data = b'123'
    list_data = [1, 2]
    tuple_data1 = tuple(str_data)
    tuple_data2 = tuple(bytes_data)
    tuple_data3 = tuple(list_data)
    print(tuple_data1, type(tuple_data1))
    print(tuple_data2, type(tuple_data2))
    print(tuple_data3, type(tuple_data3))

    输出:

    ('a', 'z') <class 'tuple'>
    (49, 50,51) <class 'tuple'>
    (1, 2) <class 'tuple'>

    2.将除list之外的序列转换为list

    str_data = 'az'
    bytes_data = b'123'
    tuple_data = (1, 2)
    list_data1 = list(str_data)
    list_data2 = list(bytes_data)
    list_data3 = list(tuple_data)
    print(list_data1, type(list_data1))
    print(list_data2, type(list_data2))
    print(list_data3, type(list_data3))

    输出:

    ['a', 'z'] <class 'list'>
    [49,50,51] <class 'list'>
    [1, 2] <class 'list'>

    四.tuple中有哪些操作方法

    count(self, value, /)
          Return number of occurrences of value.
          #统计出现的次数


     index(self, value, start=0, stop=9223372036854775807, /)
          Return first index of value.

         #返回第一个的索引(索引:从0开始)

    输入:

    tuple_data = tuple("hello")
    print(tuple_data.count("l"))
    print(tuple_data.index("l"))
    

    输出

    2
    2

    元组是固定且不可改变的。这意味着一旦元组被创建,和列表不同,它的内容无法被修改或它的大小也无法被改变。

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

    五.list中有哪些操作方法

    def append(self, *args, **kwargs):
        """ Append object to the end of the list. """
        # 将对象追加到列表的末尾。
    
    def clear(self, *args, **kwargs):
        """ Remove all items from list. """
        # 从列表中删除所有项目。
    
    def copy(self, *args, **kwargs):
        """ Return a shallow copy of the list. """
        # 返回列表的浅层副本。
    
    def count(self, *args, **kwargs):
        """ Return number of occurrences of value. """
        # 返回值的出现次数。
    
    def extend(self, *args, **kwargs):
        """ Extend list by appending elements from the iterable. """
        # 通过从可迭代对象追加元素来扩展列表。
    
    def index(self, *args, **kwargs):
        """
        Return first index of value.
        # 返回值的第一个索引。
    
        Raises ValueError if the value is not present.
        """
        # 如果值不存在,则提高值错误。
    
    def insert(self, *args, **kwargs):
        """ Insert object before index. """
        # 在索引之前插入对象。
    
    def pop(self, *args, **kwargs):
        """
        Remove and return item at index (default last).
        # 删除并返回索引处的项目(默认在后面)。
        Raises IndexError if list is empty or index is out of range.
        """
        # 如果列表为空或索引超出范围,则引发索引错误。
    
    
    
    def remove(self, *args, **kwargs):
        """
        Remove first occurrence of value.
        # 删除第一个出现的值。
        Raises ValueError if the value is not present.
        """
        # 如果值不存在,则提高值错误。
    
    def reverse(self, *args, **kwargs):
        """ Reverse *IN PLACE*. """
        # 反向
    
    def sort(self, *args, **kwargs):
        """
        Sort the list in ascending order and return None.
        # 按升序对列表进行排序,并返回 None。
        The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
        order of two equal elements is maintained).
        # 排序是就地的(即列表本身被修改)和稳定的(即保持两个相等元素的顺序)。
        If a key function is given, apply it once to each list item and sort them,
        ascending or descending, according to their function values.
        # 如果给出了一个关键功能,则将其应用于每个列表项一次并对其进行排序,
           升序或降序,根据其函数值。
        The reverse flag can be set to sort in descending order.
        """
        # 可以将反向标志设置为按降序排序。
    更多相关内容
  • 主要介绍了Python列表和元组的定义与使用操作,结合实例形式分析了Python中列表和元组的功能、区别、定义及使用方法,需要的朋友可以参考下
  • 列表和元组

    2020-12-22 01:26:36
    元组形式及元素特点3.列表与元组的区别六、编程实践1.创建一个列表2.删除列表中的重复元素3.对列表进行数据排序4.获取列表中索引为偶数的元素5.获取列表中索引为奇数的元素 一、序列 1.序列的概述  (1)序列是Python...
  • python列表和元组

    2022-06-17 18:19:52
    python列表和元组

    python列表和元组

    1、列表
    列表是Python中内置的有序可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号隔开,列表中元素的类型可以相同也可以不同。

    (1)列表的创建
    创建列表的两种方式:
    直接通过一对中括号创建列表对象;
    使用list()函数将元组、range对象、字符串或其他类型的可迭代对象转换为列表;

    (2)列表元素的索引
    列表创建完成后,主要是通过列表名[索引]来访问元素,Python中的索引支持两个方向:
    从左到右从0开始不断增大;
    从右向左从-1开始不断减小;
    因此访问列表中的某一元素,通常有两种方式,例如 a_list = [1, 3, 5, 7, 9],a_list[2]和a_list[-3]表示的都是同一个元素5。
    在这里插入图片描述

    (3)列表的切片操作
    如果想同时访问多个元素,可以使用Python中的切片操作
    语法形式为:列表对象 [start : end : step]
    start表示起始位置的索引,end表示结束位置的索引,但不包含结束位置,step表示步长,默认为1。start和end中间的冒号不可省略,其他部分都可省略。

    由于Python中支持两个方向的索引,所以start和end既可以是正数,也可以是负数,但一定要在规定的范围内,否则会报错。执行切片操作时,不管索引是正数还是负数,首先找到该索引对应的元素,找到起始元素和结束元素后,再根据步长来确定访问规则,这里的步长,也支持正数和负数,表示不同的方向。如果按照指定的方向,无法从起始元素到达结束元素,此时结果为空列表。例如:a_list = list(range(1, 10))。
    在这里插入图片描述
    在这里插入图片描述
    (4)列表内容的修改
    列表是一种可变序列,允许对其中的元素进行修改,分为三种情况:
    修改单个元素(对新的值没有特殊要求);
    修改连续的多个元素(要求新的值必须是可迭代对象);
    修改不连续的多个元素(要求新的值必须是可迭代对象,且可迭代对象中元素个数和之前的元素个数相同)
    在这里插入图片描述
    (5)列表的常见方法
    在这里插入图片描述
    在这里插入图片描述

    2、元组
    元组是Python中内置的有序不可变序列,元组的所有元素放在一对圆括号“()”中,并使用逗号隔开,元组中元素的类型可以相同也可以不同。
    (1)元组的创建
    创建元组的两种方式:
    直接通过一对圆括号创建元组对象;
    使用tuple()函数将列表、range对象、字符串或其他类型的可迭代对象转换为元组;

    注意:当元组中只包含一个元素时,元素后面的逗号不能省略,否则系统会将其看做是其他数据类型。例如包含一个整数5的元组应写成 a_tuple = (5,) 而不能写成a_tuple = (5)(此时a_tuple是整型)。

    元组和列表的联系与区别
    元组和列表之间存在很多关联,例如都可以存放多个数据,里面的数据都是有序的,支持索引、切片操作,都能使用系统中提供的一些内置函数如求最大值、最小值、求和、求长度等。
    二者之间可以通过相应的函数进行转化,二者最大的不同在于元组中的元素不能修改,因此元组不支持修改、插入、附加等操作,所有对元组有变化的操作都是生成一个新的元组,例如两个元组之间相加、元组乘以整数等。
    可以说,所有能用到元组的地方,都可以使用列表。那为什么还需要元组呢?元组操作速度比列表更快,元组的安全性更高,可以有效避免对一些不可变的内容进行修改。
    在这里插入图片描述

    总结:

    1、相同点:
    列表和元组是Python中最常用的两种数据结构,字典是第三种。

    列表与元组都是容器,都能存储任何数据类型;

    列表与元组的数据可以进行互相转化

    可以通过索引访问

    list和tuple都支持负索引

    list和tuple都支持切片操作

    list和tuple都可以随意嵌套

    2、不同点:
    列表属于动态数据,不可变但可以对元素进行增、删、改来改变元素的长度。

    元组属于静态数据,不可变类型。

    元组被定义不允许修改。

    列表定义后用户可以使用for或者while对列表中的数据进行遍历,能对列表中的元素进行增、删、改。

    一般用于存储同一类型同语义的数据的集合。

    列表与元组保存数据的格式不同,列表使用[]括号存储数据,元组使用()存储数据。

    列表和元组查询速度,元组优于列表,安全性元组比列表安全性高

    https://zhuanlan.zhihu.com/p/368121634

    展开全文
  • 主要介绍了Python数据类型之列表和元组的相关知识,列表是一组有序项目的集合 ,可变的数据类型可 进行增删改查,本文通过实例文字相结合的形式给大家介绍的非常详细 ,需要的朋友可以参考下
  • Python 列表元组

    千次阅读 多人点赞 2020-08-05 16:18:46
    在 Python 中,序列结构主要有列表元组、集合、字典字符串。对于这些序列结构有以下几个通用的操作,其中,集合字典不支持索引、切片、相加相乘操作。 索引 序列中的每一个元素都有一个编号,也成为了索引...

    作者:billy
    版权声明:著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处

    序列概述

    序列是一块用于存放多个值的连续内存空间,并且按一定顺序排序。每个值(称为元素)都分配一个数字(称为索引或位置),通过该索引可以取出相应的值。

    在 Python 中,序列结构主要有列表、元组、集合、字典和字符串。对于这些序列结构有以下几个通用的操作,其中,集合和字典不支持索引、切片、相加和相乘操作

    1. 索引
      序列中的每一个元素都有一个编号,也成为了索引(Indexing)。这个索引是从 0 开始递增的,即下标为 0 表示第一个元素,下标为 1 表示第二个元素,以此类推。

    Python 相对于 Java、C++ 不同的是,它的索引可以是负数。当索引是负数时,它是从右向左计数,也就是从最后一个元素开始计数,即最后一个元素的索引值是 -1,倒数第二个元素的索引值是 -2,以此类推。
    采用负数索引,是从 -1 开始的,这是为了防止与第一个元素重合

    示例:

    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    print(verse[2])		# 输出第三个元素
    print(verse[-1])	# 输出最后一个元素
    
    1. 切片
      切片(Slicing)操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。切片操作的语法格式如下:
      sname[start : end : step]
      sname:表示序列的名称;
      start:表示切片的开始位置(包括该位置),如果不指定,则默认为 0;
      end:表示切片的截止位置(不包括该位置),如果不指定,则默认为序列的长度;
      step:表示切片的步长,如果省略,默认为 1.当省略该步长时,最后一个冒号也可以省略;
      在进行切片操作时,如果指定了步长,那么将按照步长遍历序列的元素,否则将一个一个遍历序列

    示例:

    verse = ["青青园中葵", "朝露待日晞", "阳春布德泽", "万物生光辉", "常恐秋节至", "焜黄华叶衰", "百川东到海", "何时复西归", "少壮不努力", "老大徒伤悲"]
    print(verse[1:6])		# 获取第 2 个到第 6 个元素
    print(verse[1:6:2])		# 获取第 2 个、第 4 个和第 6 个元素
    print(verse[:])  		# 获取所有元素
    

    如果需要复制整个序列,可以将 start 和 end 都省略,但是中间的冒号需要保留

    1. 序列相加
      在 Python 中,使用(+)运算符可以实现两个相同种类的序列相加(Adding)操作,即将两个序列进行连接,但不去除重复的元素。

    示例:

    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    num = [7, 1.5, 0.28, -2, 0]
    print( num + verse )
    

    在进行序列相加时,相同类型是指同为列表、元组、字符串等,序列中的元素类型可以不同

    1. 乘法
      在 Python 中,使用数字 n 乘以一个序列会生成一个新的序列。新序列的内容为原来序列被重读 n 次的结果。

    示例:

    list = [None] * 5
    print(list)
    

    上述例子的运行结果为 [None, None, None, None, None]
    上述例子中使用序列的乘法(Multiplying)运算,实现了指定长度列表初始化的功能

    1. 检查某个元素是否是序列的成员(元素)
      在 Python 中,可以使用 in 关键字检查某个元素是否是序列的成员,即检查某个元素是否包含在该序列中;同样的,还可以使用 not in 关键字检测某个元素是否不包含在指定的序列中

    示例:

    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    print("晴空一鹤排云上" in verse)		# True
    print("自古逢秋悲寂寥" not in verse)	# False
    
    1. 计算序列的长度、最大值和最小值
      在 Python 中,提供了内置函数 len() 计算序列的长度,即返回序列包含多少个元素;使用 max() 函数返回序列中的最大元素;使用 min() 函数返回序列中的最小元素。

    示例:

    num = [7, 14, 21, 28, 35, 42, 49, 56, 63]
    print( "序列的长度为:", len(num) )		# 9
    print( "序列中的最大值为:", max(num) )		# 63
    print( "序列中的最小值为:", min(num) )		# 7
    

    Python 提供的几个内置函数及其说明

    函数说明
    list()将序列转换为列表
    str()将序列转换为字符串
    sum()计算元素和
    sorted()对元素进行排序
    reversed()反序序列中的元素
    enumerate()将序列组合为一个索引序列,多用于 for 循环中

    列表

    Python 中的列表类似于歌曲列表,是由一系列按特定顺序排列的元素组成。它是 Python 中内置的可变序列。在形式上,列表的所有元素都放在一对括号 “[]” 中,两个相邻的元素之间使用逗号 “,” 分割。在内容上,可以将整数、实数、字符串、列表、元组等任何类型的内容放入列表中,并且同一个列表中,元素的类型可以不同,因为他们之间没有关系。由此可见,Python 中的列表是非常灵活的,这一点与其他语言不同。

    1. 列表的创建和删除
      列表同其他类型的 Python 变量一样,创建列表时,也可以使用赋值运算符 “=” 直接将一个列表赋值给一个变量。

    示例:

    num = [7, 14, 21, 28, 35, 42, 49, 56, 63]
    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    python = ["优雅", "明确", "简单"]
    

    在使用列表时,虽然可以将不同类型的数据放入同一个列表中,但是通常情况下,我们都不这样做。而是一个列表中只放入一种类型的数据,这样可以提高程序的可读性

    在 Python 中,也可以创建空的列表:list = []

    在 Python 中,数值列表也是非常常用的,可以通过 list() 函数把 range 对象、字符串、元组等转换为列表,例如:
    list( range(10, 20, 2) ) # 创建一个 10 ~ 20(不包括 20)之间所有偶数的列表
    得到的结果为 [10, 12, 14, 16, 18]

    对于已经创建的列表,当我们不再使用时,可以使用 del 语句将其删除。
    del 语句在实际开发时,并不常用。因为 Python 自带的垃圾回收机制会自动销毁不用的列表

    1. 访问列表元素
      在 Python 中,如果想将列表的内容输出,可以直接使用 print() 函数,如果想输出单个元素,可以通过下标索引的方式。

    示例:

    import datetime						# 导入日期时间类
    
    # 定义一个列表
    mot = ["坚持下去不是因为我很坚强,而是因为我别无选择",
           "含泪播种的人一定能笑着收获",
           "做对的事情比把事情做对重要",
           "命运给与我们的不是失望之酒,而是机会之杯",
           "明日永远新鲜如初,纤尘不染",
           "求知若饥,虚心若愚",
           "成功将属于那些从不说 “不可能” 的人"]
    day = datetime.datetime.now().weekday()			# 获取当前星期
    print(mot[day])						# 输出每日一贴
    
    1. 遍历列表
      遍历列表中的所有元素是常用的一种操作,在遍历的过程中可以完成查询、处理等功能。在 Python 中遍历列表有以下两种方式:
    • 直接使用 for 循环
      示例:
    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    for item in verse:
        print(item)
    
    • 使用 for 循环和 enumerate() 函数实现
      示例:
    verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
    for index, item in enumerate(verse):
        print(index, item)
    

    上述例子的运行结果为:

    0 自古逢秋悲寂寥
    1 我言秋日胜春朝
    2 晴空一鹤排云上
    3 便引诗情到碧霄
    
    • 使用 for 循环和 enumerate() 函数可以同时输出索引和元素内容
      示例:
    print(" "*7, "长歌行")
    verse = ["青青园中葵", "朝露待日晞", "阳春布德泽", "万物生光辉", "常恐秋节至", "焜黄华叶衰", "百川东到海", "何时复西归", "少壮不努力", "老大徒伤悲"]
    for index, item in enumerate(verse):
        if index % 2 == 0:
            print(item + ", ", end = "")
        else:
            print(item + "。")
    

    上述例子的运行结果为:

           长歌行
    青青园中葵, 朝露待日晞。
    阳春布德泽, 万物生光辉。
    常恐秋节至, 焜黄华叶衰。
    百川东到海, 何时复西归。
    少壮不努力, 老大徒伤悲。
    
    1. 添加列表元素
      添加、修改和删除列表元素也称为更新列表,在实际开发中,经常需要对列表进行更新。

    之前介绍了可以通过 “+” 号将两个序列连接,通过该方法也可以为列表添加元素。但是这种方法的执行速度要比直接使用列表对象的 append() 方法慢。列表对象的 append() 方法用于在列表的末尾追加元素。

    示例:

    list = []
    a = 6
    while True:
        if a % 2 == 0:
            a = a / 2
        else:
            a = a * 3 + 1
        list.append(a)
        if a == 1:
            break
    print("这个列表是:", list)
    

    上述例子的运行结果为: 这个列表是: [3.0, 10.0, 5.0, 16.0, 8.0, 4.0, 2.0, 1.0]

    除了可使用 append() 方法向列表添加元素外,还可以使用 insert() 方法。insert() 方法用于向列表指定位置插入元素,由于该方法的执行效率没有 append() 方法高,所以不推荐此方法。

    如果需要将一个列表中的所有元素全部添加到另一个列表,可以使用列表对象的 extend() 方法
    示例:

    verse1 = ["常记溪亭日暮", "沉醉不知归路", "兴尽晚回舟", "误入藕花深处", "争渡", "争渡", "惊起一滩鸥鹭"]
    verse2 = ["李清照", "如梦令"]
    verse2.extend(verse1)		# extend() 方法是将第一个列表添加到第二个列表
    print(verse2)
    

    上述例子的运行结果为: ['李清照', '如梦令', '常记溪亭日暮', '沉醉不知归路', '兴尽晚回舟', '误入藕花深处', '争渡', '争渡', '惊起一滩鸥鹭']

    1. 修改、删除列表元素
      修改列表中的元素只需要通过索引获取该元素,然后再重新赋值即可。

    示例:

    verse = ["长亭外", "古道边", "芳草碧连天"]
    print(verse)
    verse[2] = "一行白鹭上青天"
    print(verse)
    

    上述例子的运行结果为:

    ['长亭外', '古道边', '芳草碧连天']
    ['长亭外', '古道边', '一行白鹭上青天']
    

    删除元素主要用两种情况,一种是根据索引删除,另一种是根据元素删除。
    删除列表中的指定元素和删除列表类似,使用 del 语句实现;
    示例:

    verse = ["长亭外", "古道边", "芳草碧连天"]
    del verse[-1]
    print(verse)
    

    上述例子的运行结果为: ["长亭外", "古道边"]

    删除一个不确定其位置的元素,可以使用列表对象的 remove() 方法;
    示例:

    verse = ["长亭外", "古道边", "芳草碧连天"]
    value = "芳草碧连天"		# 指定要移除的元素
    if verse.count(value) > 0:	# 判断要删除的元素是否存在
        verse.remove(value)		# 移除指定元素
    print(verse)
    

    上述例子的运行结果为: ["长亭外", "古道边"]
    在使用 remove() 方法前,需要判断一下该元素是否存在,如果不存在会报异常
    列表对象的 count() 方法用于判断指定元素出现的次数,结果返回为 0 时,代表不存在该元素

    1. 对列表进行统计计算
      Python 的列表提供了内置的一些函数来实现统计计算方面的功能。
    函数功能
    count()获取指定元素在列表中出现的次数
    index()获取指定元素在列表中首次出现的次数(即索引)
    sum()统计数值列表中各元素的和
    1. 对列表进行排序
      在实际开发过程中,经常需要对列表进行排序。Python 中提供了两种常用的排序方法。
    • 使用列表对象的 sort() 方法
      listname.sort(key = None, reverse = False)
      listname:表示要进行排序的列表;
      key:表示指定从每个列表元素中提取一个比较键(例如,设置 “key = str.lower” 表示在排序时不区分大小写字母)
      reverse:可选参数,如果将其指定为 True,则表示降序排序,如果为 False,则表示升序排序。默认升序排序。

    示例:

    grade = [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
    print("原列表:", grade)
    grade.sort()
    print("升序为:", grade)
    grade.sort(reverse=True)
    print("降序为:", grade)
    

    上述例子的运行结果为:

    原列表: [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
    升序为: [89, 94, 95, 96, 97, 98, 99, 100, 100, 100]
    降序为: [100, 100, 100, 99, 98, 97, 96, 95, 94, 89]
    

    使用 sort() 方法对字符串进行排序时,采用的规则是先对大写字母进行排序,然后再对小写字母进行排序.
    示例:

    char = ['cat', 'Tom', 'Angela', 'pet']
    char.sort()
    print("区分字母大小写排序为:", char)
    char.sort(key=str.lower)
    print("不区分字母大小写排序为:", char)
    

    上述例子的运行结果为:

    区分字母大小写排序为: ['Angela', 'Tom', 'cat', 'pet']
    不区分字母大小写排序为: ['Angela', 'cat', 'pet', 'Tom']
    

    注意:sort() 函数对中文的支持不是很好,如果需要实现对中文内容的列表排序,还需要重新编写相应的方法进行处理,不能直接使用 sort() 方法

    • 使用内置的 sorted() 函数
      sorted(listname, key = None, reverse = False)
      内置函数 sorted() 与列表对象 sort() 方法的作用基本相同,不同的是使用 sort() 方法时,会改变原列表的元素排列顺序,但是使用 sorted() 函数时,会建立一个原列表的副本,该副本为排序后的列表

    示例:

    grade = [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
    grade_as = sorted(grade)
    print("升序为:", grade_as)
    grade_des = sorted(grade, reverse = True)
    print("降序为:", grade_des)
    print("原列表:", grade)
    

    上述例子的运行结果为:

    升序为: [89, 94, 95, 96, 97, 98, 99, 100, 100, 100]
    降序为: [100, 100, 100, 99, 98, 97, 96, 95, 94, 89]
    原列表: [98, 99, 97, 100, 100, 96, 94, 89, 95, 100]
    
    1. 列表推导式
      使用列表推导式可以快速生成一个列表,或者根据某个列表生成满足指定需求的列表。
    • 生成制动范围的数值列表
      list = [Expression for var in range]
      list:表示生成的列表名称;
      Expression:表达式,用于计算新列表的元素;
      var:循环变量;
      range:采用 range() 函数生成的 range 对象;

    示例:

    import random
    number = [random.randint(10, 100) for i in range(10)]
    print("生成的随机数列表为:", number)
    

    上述例子的运行结果为: 生成的随机数列表为: [22, 33, 20, 23, 57, 83, 28, 20, 16, 12]

    • 根据列表生成指定需求的列表
      newList = [Expression for var in list]
      newList:表示新生成的列表名称;
      Expression:表达式,用于计算新列表的元素;
      var:变量,值为后面列表的每个元素值;
      list:用于生成新列表的原列表;

    示例:

    price = [1200, 5330, 2988, 6200, 1998, 8888]
    sale = [int(x * 0.5) for x in price]
    print("原价格:", price)
    print("打五折后的价格:", sale)
    

    上述例子的运行结果为:

    原价格: [1200, 5330, 2988, 6200, 1998, 8888]
    打五折后的价格: [600, 2665, 1494, 3100, 999, 4444]
    
    • 从列表中选择符合条件的元素组成新的列表
      newList = [Expression for var in list if condition]
      newList:表示新生成的列表名称;
      Expression:表达式,用于计算新列表的元素;
      var:变量,值为后面列表的每个元素值;
      list:用于生成新列表的原列表;
      condition:条件表达式,用于指定筛选条件;

    示例:

    price = [1200, 5330, 2988, 6200, 1998, 8888]
    sale = [x for x in price if x > 5000]
    print("原列表:", price)
    print("价值高于 5000 的:", sale)
    

    上述例子的运行结果为:

    原列表: [1200, 5330, 2988, 6200, 1998, 8888]
    价值高于 5000 的: [5330, 6200, 8888]
    

    元组

    元组(tuple)是 Python 中另一个重要的序列结构,也列表类似,也是由一系列按特定顺序排列的元素组成。但它是不可变序列,因此,元组也称为不可变的列表

    1. 元组的创建和删除
      元组的创建与列表相同,可以直接通过 "=“ 赋值给变量。

    示例:

    num = (7, 14, 21, 28, 35, 42, 49, 56, 63)
    untitle = (‘Python’, 28, ("人生苦短", "我用 Python"), ["爬虫", "自动化运维", "云计算"])
    python = ("优雅", "明确", "简单")
    

    在 Python 中,虽然元组是使用一对小括号将所有元素括起来的。但是实际上,小括号并不是必须的,只要将一组值用逗号分隔开来,Python 就会认为它是元组

    示例:

    verse = "渔舟唱晚", "高山流水", "出水莲", "汉宫秋月"
    print(verse)
    

    上述例子的运行结果为: ("渔舟唱晚", "高山流水", "出水莲", "汉宫秋月")

    如果创建的元组只包括一个元素,则需要在定义元组时,在元素后面加上一个逗号。可以使用 type() 函数测试变量的类型

    示例:

    verse1 = ("一片冰心在玉壶")
    verse2 = ("一片冰心在玉壶",)
    print("verse1 的类型是:", type(verse1))
    print("verse2 的类型是:", type(verse2))
    

    上述例子的运行结果为:

    verse1 的类型是: <class 'str'>
    verse2 的类型是: <class 'tuple'>
    

    和列表一样,也可以创建空的元组:tuple = ()
    也可以把其他类型数据转换为元组:tuple( range(10, 20, 2) )
    同样的,删除元祖可以使用 del 语句:del tuple

    1. 访问元组元素
      元组的访问也和列表相同,可以通过下标、for 循环、for 循环 + enumerate() 函数。篇幅太长不写示例了,具体请参考列表。

    2. 修改元组
      元组是不可变序列,我们不能对它的单个元素进行修改,但是可以对元组进行重新赋值

    3. 元组推导式
      与列表推导式不同的是,元组推导式生成的结果并不是一个元组或者列表,而是一个生成器对象。需要使用生成器对象再转换为元组或者列表。

    示例1:

    import random							# 导入 random 标准库
    number = ( random.randint(10, 100) for i in range(10) )
    number = tuple(number)						# 转换为元组
    print("转换后:", number)
    

    上述例子的运行结果为: 转换后: (11, 44, 72, 63, 93, 100, 36, 60, 58, 53)

    示例2:

    number = (i for i in range(4))		# 生成生成器对象
    for i in number:			# 遍历生成器对象
        print(i, end = ' ')			# 输出每个元素的值
    print(tuple(number))			# 转换为元组输出
    

    上述例子的运行结果为: 0 1 2 3 ()
    由上述例子可知,遍历完成之后,原生成器对象已经不存在了。如果还需要使用,则必须重新创建一个生成器对象

    元组与列表的区别

    1. 列表属于可变序列,它的元素可以随时修改或者删除。元组属于不可变序列,其中的元素不可以修改,除非整体替换;
    2. 列表可以使用 append()、extend()、insert()、remove() 和 pop() 等方法实现添加和修改列表元素,而元组则没有这几个方法,因为不能向元组中添加、修改和删除元素;
    3. 可以使用切片访问和修改列表中的元素。元组也支持切片,但是它只支持通过切片访问元组中的元素,不支持修改;
    4. 元祖比列表访问速度和处理速度快。所以如果只需要对其中的元素进行访问,而不进行任何修改,建议使用元组而不使用列表;
    5. 列表不能作为字典的键,而元组可以;

    更多请参考

    展开全文
  • 列表元组、字典、集合之间的关系以及区别

    千次阅读 多人点赞 2021-03-11 21:30:10
    字符串、列表元组、字典1.字符串2.列表 1.字符串 1.1 Python中的字符串可以使用单引号、双引号和三引号(三个单引号或三个双引号)括起来,遇到重复使用时可以使用反斜杠\转义特殊字符。 使用转义字符: my_str = ...

    1.必看

    1.1列表、元组、字典、集合的区别
    列表:顺序存储结构,占更多存储空间(默认存了指针),元素不必相同,用"[]“表示。
    元组:元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示。
    字典:字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。定义 Dictionary 使用一对大(花)括号”{}"。(其中前三个也可称之为Python的数组类型)
    集合:用的比较少,无序不重复元素集。
    1.2
    序列都可以进行的操作包括索引,切片,加,乘,检查成员。
    此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
    1.3为什么有了列表还要有元组、字典、集合?
    降低程序的时间复杂度
    比如字典:Python字典因为在存储元素时,将key哈希转化到了存储地址,所以如果要在字典里查找某个元素的key,不需要循环字典,只需要进行同样的哈希计算就可以得到了。
    1.4本文属于学习笔记,所以很多具体的知识点并没有记录,关于具体知识点可以访问菜鸟教程

    2.列表、元组、字典、集合最基本的创建

    2.1
    列表的创建

    a = [1,2,3]
    

    字典的创建(字典中每一对数据都是‘键’和‘值’相对应的)

    a = {key1:value1,key2:value2}
    

    元组的创建

    t = (1,2,3)
    

    集合的创建

    s = {'s','e','t'}
    

    2.2
    用list()、tuple()、dict()、set()内置方法转换

    s = set([1,2,3])
    

    3.列表

    3.1列表的三个优点:
    1.列表里想装啥就装啥,即:他可以包含不同种类、任意类型的对象,甚至可以嵌套列表,专业点的词儿叫:异构性;所以,列表里面的数据可以是不同类型的数据。
    2.列表里装的元素都是有顺序的,可以按照位置序号获取单个元素,也可以用分片的方法来进行多个连续元素的获取,来个专业词汇,叫做:有序性。所以,列表的下标可以进行索引和切片。
    3.列表的大小和内容可以随意改变,在插入、删除、修改列表元素时,不需要建立一份新的列表拷贝,而是在原来的内存地址上直接修改列表对象。这个叫“本地可修改”。所以,列表可以删除元素,列表拼接等。
    3.2列表常见操作和方法
    1.列表的索引
    2.列表的分片操作
    3.列表删除元素
    4.列表的拼接
    5.列表的重复
    6.元素成员判断
    7.求列表的长度
    8.求列表的最大、最小值
    9.在列表中插入元素
    10.反转一个列表
    11.计算列表中指定元素x的个数
    12.查找列表中指定元素的位置
    13.列表的排序

    4.元组

    元组类似于列表,是一个基于位置的有序对象集合,但是元组一旦创建之后就不能更改,因此列表中修改元素的操作对于元组都不适用。

    • 为什么要使用元组?

    元组和其他不可变量类似于其他语言中“常量”的声明,它的不可变性提供了某种一致性,这样可以确保元组在程序中不会被另一个引用修改。
    Mark Lutz——《Learning Python》中文版

    5.字典

    5.1常见操作方法

    操作解释
    .key()获取所有键
    .values()获取所有值
    .items()获取所有“键+值”元组
    len()获取键值对的数量
    .get(key,default)获取键的值,若键不存在,则返回设定的默认值default(默认为None)–与[key]获取值的区别是,get方法遇到键不存在的时候会返回设定值,而直接索引遇到键不存在时会报错“missing-key”
    dict1.update(dict2)合并两个字典

    5.2索引

    dict1[key]
    #key是字典的键,返回的是对应的值value
    dict1.get(key)
    #get方法获取键的值,若键不存在,则返回设定的默认值default(默认为None)--与`[key]`获取值的区别是,get方法遇到键不存在的时候会返回设定值,而直接索引遇到键不存在时会报错“missing-key”
    

    5.3遍历

    for i in dict1.keys():
    	print(i, dict1[keys]) 
    # 遍历字典中所有的键,并输出键值对 
    for i in dict1: 
          ...
    # 该方法与上述方法等价 
    for keys, values in dict1.items():
         ... 
    # 遍历字典中所有的键值对 
    

    5.3排序
    1.①借助.keys()方法和list()函数将键提取成list,对list排序后输出

    D = {'a':1, 'c':3, 'b':2}
    D1 = list(D.keys())
    D1.sort()
    for i in D1: 
        print(i, D[i])
    # 输出:
    # a 1
    # b 2
    # c 3
    

    ②借助内置的sorted()函数可对任意对象类型排序,返回排序后的结果。
    tips:对于sorted(字典)来说,返回的是排序好的keys(以list的形式)

    D = {'a':1, 'c':3, 'b':2}
    for i in sorted(D):
        print(i, D[i])
    # 输出:
    # a 1
    # b 2
    # c 3
    

    2.用字典的值对字典进行排序,将{1: 2, 3: 4, 4:3, 2:1, 0:0}按照字典的值从大到小进行排序。

    a = {1:2,3:4,4:3,2:1,0:0}
    sorted_a = sorted(a.items(),key=lambda a:a[1],reverse=False)
    print(sorted_a)
    

    ★sorted(iterable, key=lambda a:a[1], reverse=False)
    ①其中iterable是可迭代对象
    ②reverse = True 降序 , reverse = False 升序(默认)
    ③key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    ④key=lambda a:a[1],是个lambda表达式,冒号右边的值返还给a。而a[1]表示a下标为1的值返还给a,最后,lambda表达式的值让key这个变量来指向。

    6.集合

    6.1

    • 为什么使用集合?
      1.由于集合内元素是不重复的,因此可以将list或其他类型的数据转换成集合,从而过滤掉其中的重复元素
      2.通过集合的交并补等操作,可以比较列表、字符串以及其他可迭代对象的差异。

    6.2集合的常用操作

    set1 `&` set2 
    #交运算
    set1 `|` set2 
    #并运算
    set1 `-` set2 
    #差运算,set1减去set1 `&` set2部分
    

    6.3集合的常用方法

    set1.add('x')  
    #添加元素。注意:集合中只能包含可哈希的对象,即list,dict都不能嵌入到集合中
    set1.union(...)  
    #取并集,效果等同于 | ,但是括号里可以是list,tuple,其他dict甚至是dictset1.intersection(...)  
    #取交集,同上set1.issubset(set2)  
    #判断set1是否是set2的子集
    
    展开全文
  • 谈谈Python中列表元组和数组的区别和操作

    千次阅读 多人点赞 2020-08-30 11:16:42
    今天给大家讲讲Python中列表List、元组Tuple、数组Array的区别和操作总结,话不多说,马上开始。01列表(List)1.列表的特点列表是以方括号“[]”包围的数据集合,不同...
  • 并以元组形式表现数据: ((1.0, 0.0, 3.0, 180.0), (2.0, 0.0, 2.0, 180.0), (3.0, 0.0, 1.0, 180.0), (4.0, 0.0, 0.0, 180.0), (5.0, 0.0, 3.0, 178.0)) 方法一,使用python内建的数据处理库: #python自带的...
  • 4.元组和列表在结构没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示。元组一旦定义其长度内容都是固定的。一旦创建元组,则这个元组就不能被修改,即不能对元组进行更新、增加、删除操作...
  • ● 掌握元组和列表区别● 掌握元组的声明赋值● 掌握适用于元组的相关运算Python元组和Python列表数据类似,都是线性表。唯一不同的是,Python元组赋值后所存储的数据不能被程序修改,可以将元组看作是只能读取...
  • python_列表和元组

    千次阅读 2020-12-17 23:21:38
    1.1.列表定义列表是python中内置有序可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号分隔开;一个列表中的数据类型可以各不相同,可以同时分别为整数、实数、字符串等基本类型,甚至是列表、字典以及...
  • 列表元组

    千次阅读 2019-05-15 22:15:34
    2.序列数据类型包括:字符串,列表,和元组类型。 3.特点: 成员关系操作符, 连接操作符, 重复操作符, 索引与切片操作符 列表的创建与删除 数组: 存储同一种数据类型的集。scores=[12,95.5] 列表(打了激素的数组):...
  • python的元组和列表

    2022-03-11 08:03:12
    一.元组的概念: 前面我们学过数字类型,字符串类型,它们都代表一个元素!...元组也可以作为另一个元组的元素,只是此时作为元素的元组要加上括号来区分,从而避免歧义! t3 = 123456,("hello","da") print
  • 主要介绍了Python中列表元组的乘法操作,结合简单实例形式分析了Python中列表元组的乘法,并附带分析了字符串的乘法及元组乘法操作的注意事项,需要的朋友可以参考下
  • (3)python 列表和元组

    2020-11-26 08:21:32
    列表和元组的主要区别:列表是可以修改的,元组不可以修改。列表用[]表示,元组用()表示一、列表、元组的通用用法1.通过索引使用元素也可以直接使用索引,不需要赋值给变量如果函数返回一个序列,可对返回结果进行...
  • 主要介绍了Python3实现对列表元组指定列进行排序的方法,结合实例形式分析了Python3针对列表排序的常见操作技巧与注意事项,需要的朋友可以参考下
  • 主要介绍了Python字符串、列表元组、字典、集合,结合实例形式详细分析了Python字符串、列表元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • python系列之:列表元组、集合、字典的区别一、列表元组、集合、字典的区别二、for循环遍历列表元组、字典集合1.遍历列表2.遍历元组3.遍历字典4.遍历集合三、列表元组、集合字典相互转换1.列表元组转化...
  • 列表元组和字典

    2020-12-12 13:42:23
    列表元组和字典 1. 通用序列操作 Pyhton中有六种内置序列:列表元组、字符串、Unicode字符串、buffer对象xrange对象,其中列表元组和字符串这三种序列是最常见的。 Python中的大部分序列都可以进行通用操作...
  • 二、列表和元组

    2021-05-22 18:54:19
    2.1copy() clear() 方法实例 2.2列表推导式(列表解析) 2.3方法列表 二、元组 1.元组的性质 2.元组的内置函数 三、其他 1.list、tuple、str之间的相互转化 2.python的负数索引 一、列表 1.列表的常用...
  • 集合类型及操作集合类型定义集合处理函数及方法集合类型应用场景序列类型及操作序列类型定义序列处理函数及方法序列类型应用场景(元组列表)元组类型及操作元组类型定义元组类型操作列表类型及操作列表类型定义列表...
  • Python列表元组、集合、字典的区别和相互转换 - CSDN博客原 Python列表元组、集合、字典的区别和相互转换2017年04月28日 11:40:0
  • 第5章 列表元组

    2020-12-24 13:33:54
    目录5.1 列表的概念5.1.1 列表的创建5.1.2 列表的索引与切片5.1.3 列表的遍历5.2 列表的运算5.3 列表的常用操作5.3.1 修改元素5.3.2 添加元素...运算5.5.5 元组列表转换5.6 小案例5.6.1 案例一5.6.2 案例二本章小结...
  • 本次学习笔记的内容主要是Python列表和元组。什么是列表(list),简单的可以理解为数组,但是比数组的范围要大,Python的列表就是一个大染缸,什么乱七八糟的元素都能往里面装。好了,废话不多说,直接动手...
  • list,tuple,set,dict区别总结图: 1.列表list [] 列表是处理一组有序的数据结构,可以读写,添加删除,或者搜索列表里的元素。因为可以添加删除,所以称为可变的数据类型,即这种类型是可以被改变的,并且...
  • python的re模块的findall()函数会返回一个所有匹配到的内容的列表,在将数据存入数据库时,列表数据类型是不被允许的,而是需要将其转换为元组形式。下面看下,str/list/tuple三者之间怎么相互转换。 class ...
  • 一、列表(List)1.列表的特点列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。如 L = [1,2,3], 列表a有3个成员。列表是可变的数据类型【可进行增删改查】,列表中可以包含任何数据类型,也可以包含另一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 134,930
精华内容 53,972
关键字:

列表和元组形式上的区别