精华内容
下载资源
问答
  • 列表与元组的不同
    千次阅读 多人点赞
    2020-08-05 16:18:46

    作者: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. 列表不能作为字典的键,而元组可以;

    更多请参考

    更多相关内容
  • (2)元素:列表元组的元素可以是不同数据类型,可重复。 2、 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。 3、Python中常见的...
  • 作业:列表元组

    2020-12-22 00:23:49
    2)Python中,常见序列有列表元组、字符串。 3)序列可以进行的操作,有索引,切片,加,乘,检查成员。 此外, Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 列表是最常用的Python数据类型,它可以...
  • python列表与元组

    2020-12-26 14:05:08
    1.列表是由一组任意类型的值组合而成的序列,组成列表的值称为元素,每个元素之间用逗号隔开。 例:list=【1,2,3,4】 #元素为int类型。 2.列表中的元素是可变的,这意味着可以向列表中添加、修改和删除元素。 例...

    一.列表的概念:
    列表是Python以及其他语言中最常用到的数据结构之一。Python中使用中括号[]来表示列表。
    二.列表的创建:
    1.列表是由一组任意类型的值组合而成的序列,组成列表的值称为元素,每个元素之间用逗号隔开。
    例:list=【1,2,3,4】 #元素为int类型。
    2.列表中的元素是可变的,这意味着可以向列表中添加、修改和删除元素。
    例:name,age,score = ‘小武’,22,95
    list1 = 【name,age,score】
    print(list1)
    3.还可以通过list()函数创建列表。
    例:list1 = list(range(1,5))
    range()函数的用法:
    在这里插入图片描述

    三.列表的索引与切片
    列表的索引与字符串的索引类似,都分为正向与反向索引。
    在这里插入图片描述

    四.列表的遍历:
    1.通过while循环遍历列表,需要用len()函数。
    2.通过for循环遍历列表,只需要将列表名放在for语句中in关键词之后。
    列表和字符串类似:
    在这里插入图片描述

    列表的常用操作:
    一.修改元素:
    只需索引修改的元素并对其赋新值。
    二.添加元素:
    在这里插入图片描述
    三.删除元素:
    在这里插入图片描述

    四.查找元素位置:
    ndex()函数可以从列表中查找出某个元素第一次出现的位置,其语法格式如下:
    在这里插入图片描述

    其中,obj表示需要查找的元素,start表示查找范围的起始处,end表示查找范围的结束处(不包括该处)。
    五.元素排序:
    列表中的元素排序,可使用sort()函数。reverse()函数可以将列表中的元素反转(也称为逆序)。
    六.统计元素个数:
    count()函数可以统计列表中某个元素的个数。
    元组:
    元组与列表类似,也是一种序列,不同之处在于元组中元素不能被改变,并且使用小括号中的一系列元素。
    一.元组的创建:
    创建元组,只需要用逗号将元素隔开。
    通常通过小括号将元素括起来。
    还可以创建一个空元组。
    示例:tuple1=(1,)
    此示例要注意,此处逗号必须添加,如果省略,则相当于在一个普通括号内输入了一个值。此处添加逗号后,就通知解释器,这是一个元组。
    二.元组的索引:
    元组可以使用下标索引来访问元组中的一个元素,也可以使用分片访问多个元素。
    注意不能通过下标索引修改元组中的元素:
    在这里插入图片描述

    三.元组的遍历:
    元组的遍历与列表的遍历类似都可以通过for循环实现。
    四.元组的运算:
    元组的运算与列表的运算类似。
    五.元组与列表转换:
    list()函数可以将元组转换为列表,而tuple()函数可以将列表转换为元组。

    展开全文
  • 列表与元组

    2020-03-18 18:21:25
    (2)元素:列表元组的元素可以是不同数据类型,可重复。 2、 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。 3、Python中常见的...

    列表和元组
    内容描述:序列常用方法、列表、元组,列表的常用方法以及元组的常用方法。
    一、序列概述
    1、概念:(1)索引:从0开始,最后是-1,数据类型为整型(int)
    (2)元素:列表和元组的元素可以是不同数据类型,可重复。
    2、 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。
    3、Python中常见的序列有列表、元组、字符串。
    4、序列可以进行的操作,有索引、切片、加、乘、检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
    5、列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现
    6、列表的数据项不需要具有相同的类型。
    7、创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。
    8、通用序列操作:(1)索引(2)切片(3)序列相加(4)乘法(5)常用内置函数:长度len();最小值min();最大值max()。
    二、列表
    1、列表元素特点:可修改、可重复、可嵌套、支持多种数据类型。
    2、函数list()
    3、基本列表操作
    ①创建 name=list()或[]或[1,2]或[1,[1,2]] ②增 append extend ③删 del clear pop remove ④改 name[1]=2 ⑤查 1.count,index 2.内置函数 min,max,len,in,not in
    4、其它操作①反转 reverse ②排序 sort(数据类型必须相同)
    5、操作
    创建/查询/修改:

    1 list_name = [数据项1, 数据项2, 数据项3…] # 创建
    2 list_name[index] # 通过索引获取列表的值,注意索引的index的范围
    3 list_name[index] = new_value # 修改列表的值
    4
    5 #eg
    6 lList = [1,2,3, [2,‘34’],(1,23)]

    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述三、元组
    1、元组元素特点:可重复,不可修改,可嵌套,支持多种数据类型。
    2、元组与列表类似,不同之处在于元组的元素不能修改。
    3、元组使用小括号,列表使用方括号。
    4、元组创建很简单,只需要在小括号中添加元素,并使用逗号隔开即可。
    5、操作
    创建/查询元组
    classmates = (‘Michael’, ‘Bob’, ‘Tracy’) # 元组中有多个元素
    t = (1, ) # 定义元组中只有一个元素, 必须有逗号","来消除歧义(因为括号“()”既可以表示元组, 又可以表示数学公式中的小括号, 这就产生了歧义);
    t = () # 定义一个空元组
    t = (‘a’, ‘b’, [‘A’, ‘B’]) # 元组中的元素数据类型可以不同

    t[0] # 取到到元组的第一个元素
    t[t.length-1] # 取到元组的最后一个元素
    t[-1] # 取到元组的最后一个元素
    t[-2] # 取到倒数第二个元素
    四、列表的常用方法
    (1)列表的插入操作。
    生成一个列表list1,使用方法list1.append([7,8,9])表示在list1后面添加列表[7,8,9];使用方法list1.extend([7,8,9])表示在list1后面添加列表[7,8,9]的所有元素。
    (2)列表的元素插入和删除。
    上个方法append和extend也可以对插入元素,不过是在列表末尾,如果要在任意位置插入元素,需要使用方法insert;list1.insert(3,‘python’)表示在索引位置是3的前面插入字符‘python’;list1.remove(‘python’)表示把元素‘python’移除列表;list1.pop(7)表示把索引位置为7的元素移除列表;
    (3)列表的切片和修改元素。
    list1[2:6]表示列表的第3到第6个元素;
    list1[1]='x’表示把列表的第2个元素修改为‘x’;
    list1[1::3]=[11,12,13]表示从列表的第二个元素开始,每3个元素分别赋值为11,12,13,
    (4)列表的元素计数和切片删除。
    list1.count(9)表示列表list1中元素9的个数;
    del list1[3:6]表示在列表list1中把第4-6共3个元素从列表删除;
    (5)列表的元素索引位置和列表的反转。
    list1.index(9)表示列表中9的索引位置;
    list1.reverse()表示把list1的各个元素反转(从后向前颠倒过来),
    (6)列表的元素排序。
    先生成一个列表list2,使用list2.sort()则是对列表进行排序(默认升序),
    五、元组的常用方法
    元组被称为只读列表,数据可被查询,但不能被修改,对于一些不想被修改的数据,可以用元组来保存。
    (1)创建元组
    创建一个元组,只需要括号中添加元素,元素用逗号隔开即可
    tuple = (1,2,3,4,5)
    tuple=(1,) #创建单个元素的元组,需在结尾添加豆号
    tup = (1,2,[“a”,“b”,“c”],“a”) #创建多个元素的元组
    (2)查询
    tuple[x] #查询索引为x的元素
    tuple[1:] #切片查询,在list结合中有提到,使用方法一致
    (3)注意事项:
    ①当元组中一个元素时,一定要在元素后面加上逗号。。
    ②元组中的元素是不允许删除的,但可以使用del语句来删除整个元组。
    ③元组没有列表中的增、删、改的操作,只有查的操作。
    六、列表和元组的相互转换
    l = [1,2,3,4]
    #列表转换为元组
    t = tuple(l)
    #元组转换为列表
    l2 = list(t)

    展开全文
  • 相同点:属于有序序列、可以强制转换、使用len()统计元素个数、使用count()统计指定元素的出现次数。不同点:1、元组类型为tuple,列表类型为...Python列表元组的相同点与不同点1.相同点( 1 )索引相同,从左到右都...

    相同点:属于有序序列、可以强制转换、使用len()统计元素个数、使用count()统计指定元素的出现次数。不同点:1、元组类型为tuple,列表类型为list;2、元组不能修改,列表可以根据索引来修改元素值;3、列表可删除元素,元组不行。

    94ba3706cea1a5b35f436320bbbd8380.png

    本教程操作环境:windows10系统、python3.9版本、Dell G3电脑。

    Python列表、元组的相同点与不同点

    1.相同点

    ( 1 )索引相同,从左到右都为0~~n-1。

    ( 2 )拼接相同,都可以用“+”拼接。

    ( 3 )计数相同,都使用len()函数统计元素个数、使用count()函数统计指定元素的出现次数。

    ( 4 )都属于有序序列。

    ( 5 )都可以使用del删除。

    ( 6 )都可以使用“*”来使本身重复。

    ( 7 )都可以强制转换。

    ( 8 )切片方法都一致。

    ( 9 )都可以使用for循环来进行元素遍历、索引遍历以及枚举遍历。

    ( 10 )使用index()方法获取指定元素的索引。

    ( 11 )使用运算符in测试是否包含某个元素

    2.不同点

    2.1类型不同。元组类型为:tuple

    列表类型为:list

    2.2修改方式不同元组不能修改

    列表可以根据索引来修改元素值

    2.3删除方式不同列表使用pop()等函数删除元素函数名描述pop()删除指定索引对应的元素,并返回删除的元素。如果不指定索引,默认删除最后一个元素

    remove()移除第一次遇到的指定元素

    del移除元素或列表,清除地址

    clear()移除列表,保留地址,只清空内容

    list=[]清空列表元组不能删除元素,只能用del删除整个元组。

    2.4查找方式不同元组只能用Index()函数来查看。

    列表只能用Index()函数来查看。

    更多编程相关知识,请访问:编程入门!!

    展开全文
  • 第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列表元组

    2022-06-17 18:19:52
    python列表元组
  • 列表可以更新,元组不可以更新,换句话讲,列表中的元素可以被修改,元组中的元素不可以被修改 例如: tuple = (1,2,3,4) list = [1,2,3,4] tuple[0] = 5 // 不合法 print(tuple) // 报错 TypeError: 'tuple' ...
  • 元组(tuple):与列表类似,不同之处在于不能修改元组的元素,元组使用圆括号包含元素,而列表使用方括号包含元素。;1.访问元组;2.合并元组;3.元组的遍历;Python提供的元组内置函数有len()、max()、min()和tuple...
  • 序列是一个基类类型,具体可以表现为字符串类型、元组类型、列表类型。 序列是一维元素向量,元素类型可以不同。 它类似于数学当中的元素序列(数列):s1,s2,…,sn-1。 元素间由序号引导,通过下标访问序列的...
  • 本节简要总结Python中数组、列表元组、Numpy数组、Numpy矩阵的概念联系。 1. 数组 Python没有数组!!! 2. 列表 python内置类型,即动态数组,C++标准库的vector,但可含不同类型的元素于一个list中。 下标:按...
  • 列表元组的区别相同点

    千次阅读 2021-10-01 21:50:58
    虽然有着一定的相似之处,但列表元组在本质上和内部实现上都有着很大的不同。 1、元组属于不可变(immutable)序列,一旦创建,不允许修改元组中元素的值,也无法为元组增加或删除元素。因此,元组没有提供append...
  • 列表元组的区别

    2022-05-07 18:14:11
    一、列表元组的区别 列表是动态数组,它们可变且可以重设长度(改变其内部元素的个数)。 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。 元组缓存于Python运行时环境,这意味着我们每次使用元组...
  • python列表与元组的用法目录:列表的用法:1.增 append + extend2.删 del remove3.改 insert4.查 index5.反向 reverse6.排序 sort7.列表生成式 #[i*i for i in range(10)] [i*i for i in range(10) if i>5]元组的...
  • Python 中最常见的两种数据结构:列表(list)和元组(tuple) 一、列表元组基础 首先,需要弄清楚最基本的概念,什么是列表元组呢? 实际上,列表元组,都是一个可以放置任意数据类型的有序集合 1.1 列表元组的...
  • 列表元组,都是一个可以放置任意数据类型的有序集合。在绝大多数编程语言中,集合的数据类型必须一致。不过,对于 Python 的列表元组来说,并无此要求。 列表: l = [1, 2, 'hello', 'world'] l [1, 2, 'hello...
  • python列表元组的区别

    千次阅读 2022-05-31 17:06:30
    一.list(列表)和tuple(元组)共同点和区别 二.定义一个变量,包含现在所学的数据类型 三.目前学到的序列有哪些? 1.将除tuple之外的序列转换为tuple 2.将除list之外的序列转换为list 四.tuple中有哪些操作...
  • 列表元组,集合总结
  • 除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗? a = [1, 3, 5, 7, 'a'] b = (1, 3, 5, 7, 'b') # 现在改变b中的值 b[2] = 4 ...
  • Python 习题讲解 列表 元组 其他 1. Python 习题部分 要想学习一门语言,便少不了练习。 故附上部分 Python 习题,供大家学习参考。 如有错误之处,还望指正! 1. 二年级一班举行了数学考试,学生小明90分,小红85...
  • Python列表元组比较

    2021-09-26 09:33:26
    1.1 列表元组基本异同点 1.2 列表元组存储方式的差异 1.3 列表元组的性能 1.4 列表元组的使用场景 本文主要梳理了下Python的基本知识点,比如Python的数据类型及区别、输入输出、条件循环、异常...
  • 五 Python 列表与元组

    2019-12-03 01:19:10
    Python有6个序列的内置类型,但最常见的是列表元组。 序列都可以进行的操作包括索引,切片,加,乘,检查成员。 此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 列表是最常用的Python...
  • Python的元组与列表类似,不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。如下实例:tup1 = ('physics', 'chemistry', 1997, 2000...
  • 虽然有着一定的相似之处,但列表元组在本质上和内部实现上都有着很大的不同元组属于不可变(immutable)序列,一旦创建,不允许修改元组中元素的值,也无法为元组增加或删除元素。因此,...
  • 和c++的不同之处,c++必须是规定类型,如int a[10];在python中可以保存n个数据,并且每个数据类型可以不一样。 1.列表的定义 names=["小红",小李] int a[10] 等价于names=[“小红”,“小李”]。 和c++一样,下...
  • 一、列表元组的性能:本文的知识点的总结是我在极客时间付费课程《Python核心技术实战》上的笔记,这门课不错,推荐订阅,一起进步。通过这两篇的讲解(《列表元组一》、《列表元组二》),我们知道了:元组比...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,400
精华内容 48,160
关键字:

列表与元组的不同