精华内容
下载资源
问答
  • Python列表与元组

    2020-10-13 13:07:53
    Python列表与元组 文章目录Python列表与元组列表List元组Tuple 列表List 列表是什么? 列表是Python的内置类型,是一种有序集合,可以随时添加和删除其中的元素。 列表定义 >>>classmates=['Michael','...

    Python列表与元组

                             自律 学习 坚强 ,拒绝迷茫。
    

    作者:行走的皮卡丘
    日期:2020
    信息:在广东石油化工学院(电子信息工程学院学院)创造不一样的人生。
    语言:golang(go)语言,python,kotlin,还有HTML,CSS,JavaScript等等。
    正在努力中…

    列表List

    1. 列表是什么?

      列表是Python的内置类型,是一种有序集合,可以随时添加和删除其中的元素。

    2. 列表定义

      >>>classmates=['Michael','Bob','Tracy']
      >>>list=[1,2,3,4,5]
      >>>list1=['Hello',1,TRUE,3.1415926]#列表元素类型可以不相同
      >>>list2=['']
      
    3. 访问列表的值

      >>>print(classmates[1])
      >>>print(list[:2])#列表切片
      >>>print(list2[1:3])
      
    4. 更新列表

      list.append('append')
      list[2]=6
      
    5. 删除列表元素

      del list[2]
      
    6. Python列表脚本操作符

      Python表达式 结果 描述
      len(list) 6 长度
      [1,2,3]+[4,5,6] [1,2,3,4,5,6] 组合
      [‘Hi!’]*4 [‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’] 重复
      3 in [1,2,3] True 元素是否存在于列表中
      for x in [1,2,3]: print(x) 1 2 3 迭代
    7. Python列表函数&方法

      序号 函数
      1 len(list)#列表长度
      2 max(list)#列表最大值
      3 min(list)#列表最小值
      4 list(tuple)#将元组转换为列表
    8. 列表方法

      方法 解释
      list.append(obj) 在列表末尾添加新对象
      list.count(obj) 统计某个元素在列表中出现的次数
      list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值
      list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
      list.insert(index,obj) 将对象插入列表
      list.pop() 移除列表中的一个元素(默认最后一个元素),并返回该元素的值
      list.remove(obj) 移除列表中某个值的第一个匹配项
      list.reverse() 反向列表中元素
      list.sort(cmp=None,key=None,reverse=False) 对原列表进行排序

      参考代码文件list_test.py

    元组Tuple

    1. 什么是元组

      元组是另一种有序序列,tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改。其他操作同列表基本相似。

    2. 元组的定义

      t=(1,)#定义只有一个元素的元组
      t=(1,2,3,4)
      
    3. 元组的一个陷阱

      首先,很清楚的一点是tuple是不可修改的,但是当元组中嵌套列表时确实一种特例

      t=('a','b',['A','B'])
      t[2][0]='X'
      t[2][1]='Y'
      

      此时t中的AB变成了XY,关于这种变化的原因是,python中的变量与实际值是通过指针联系起来的,这样的话修改的只是列表中的值,但是元组中指向列表的指针值并没有发生变化,元组不可修改的基本原则还是满足的。

      详细说明如下:

      • 首先看定义时tuple中的3个元素

      • A,B修改成X,Y之后,tuple变为

        表面上看,tuple的元素确实变化了,但其实变的不是tuple的元素,而是list的元素,tuple一开始指向的list并灭有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向a,就不能改成指向b,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

    展开全文
  • python列表与元组

    2017-12-26 14:54:00
    python列表与元组 /* GitHub stylesheet for MarkdownPad (http://markdownpad.com) */ /* Author: Nicolas Hery - http://nicolashery.com */ /* Version: b13fe65ca28d2e568c6ed5d7f06581183df8f2ff */ /* ...
    python列表与元组

    列表与元组

    python中最基础的两种集合,区别:列表是动态的,大小可以改变,元组是不可变的,一旦创建就不能修改
    ,因为不变性,所以元组是可哈希的。

    列表的介绍

    列表是对其他对象的引用组成的连续数组,因为是数组,所以数组有的优点列表都有,查找效率比链表高,插入与删除的操作效率比链表低。python的列表不是链表,需要真正的链表的时候,python在内置collections模块中提供了deque(双端队列),他是栈和队列的一般化(是双向链表)

    列表推导

    在使用常规的for循环往列表中添加数据时,因为python是解释型语言,解释器每次循环都需要判断序列中需要修改的部分,并且需要用一个计数器来跟踪需要处理的元素,并且在添加时使用append()方法是列表方法,,每次遍历还需要额外执行查找append函数的查询函数,列表推导正式解决这个问题的正确方法,它对上述一部分做了自动化处理,提高了效率
    普通for循环添加数据

    events=[]
    for i in range(10):
        if i%2==0:
            events.append(i)
    

    使用列表推导

    events=[i for i in range(10) if i%2==0]

    enumerate(枚举)

    在循环使用序列时,都可以使用枚举这个内置函数获取其索引,不止列表可以,但凡是序列类型的都可以,包括字符串:

    for i,e in enumerate('hello'):
    ... print(i,e)
    ...
    0 h
    1 e
    2 l
    3 l
    4 o

    如果需要合并多个列表中的元素,可以使用内置的zip()函数。对两个大小相等的可迭代对象进行均匀遍历时,

     for item in zip([1,2,3],[4,5,6]):
    ... print(item)
    ...
    (1, 4)
    (2, 5)
    (3, 6)

    调用两次zip时,可将其恢复原状

     for item in zip(*zip([1,2,3],[4,5,6])):
    ... print(item)
    ...
    (1, 2, 3)
    (4, 5, 6)

    zip([1,2,3],[4,5,6])返回的是地址名,只有使用指针*zip([1,2,3],[4,5,6])才可以有返回值

    序列解包

    使用任意序列类型,只要赋值运算符左边的变量数目与序列中的元素数目相等,都可以将序列中的元素解包到左边的变量中去

    a,b,*c='hello'
    >>> a
    'h'
    >>> b
    'e'
    >>> c
    ['l', 'l', 'o']
    使用*号
    >>> a,*b,c=0,1,2,3
    >>> a,
    (0,)
    >>> b
    [1, 2]
    >>> c
    3
    嵌套解包
    >>> (a,b),(c,d)=(1,2),(3,4)
    >>> a
    1
    >>> b
    2
    >>> c
    3
    >>> d
    4

    转载于:https://www.cnblogs.com/dcotorbool/p/8117969.html

    展开全文
  • 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. 列表不能作为字典的键,而元组可以;

    更多请参考

    展开全文
  • python 列表与元组

    2019-10-22 21:58:24
    列表与元组 一、列表: 1.一般列表 2.混合列表 3.空列表 二、添加列表成员: 1.list.append() ,一次只能添加一个参数。 2.list.extend() , 使用一个列表来扩张另一个列表,所以函数里的参数只能是列表。 3.list....

    列表与元组
    一、列表:
    1.一般列表
    2.混合列表
    3.空列表
    二、添加列表成员:
    1.list.append() ,一次只能添加一个参数。
    2.list.extend() , 使用一个列表来扩张另一个列表,所以函数里的参数只能是列表。
    3.list.insert( 排名,参数), 第一个的排名为0。
    4.可以利用中间参数来改变列表里面参数的排序。
    三、删除列表元素:
    1.list.remove() , 括号里直接填入要删除的参数名。
    2.list.del ,直接删除整个列表,del后直接接列表名。
    3list…pop() ,默认将列表的最后一个参数提取出来,列表的最后一个元素将不会再存在与原来的列表,如果括号内有数字则将该序号的元素提取出来。例如:name=member.pop()
    四、列表切片
    列表名[开始的序号:结束的序号],切片提取出来的列表,不包括结束的参数,对原列表没有影响,相当于一个列表的拷贝。如果开始的序号空白则代表从最前的参数开始,结束的序号也是。
    五、列表中常用的操作符:
    在这里插入图片描述
    1.列表的大小比较
    两个列表相比,如果是多个参数的则都从第一个开始比较,只要有一个参数比出大小就可以判断列表的大小比较。
    2.列表的相加与乘法
    两个列表可以通过“+”相加,但是不能列表+元素。用*n将成员参数复制n被
    3.判断列表元素是否存在
    元素 in list 可返回一个bool值判断元素是否在列表内,如果元素在列表的列表里则无法判断,会判断出不在,但可以写成元素 in list [列表序号]判断。 list{序号][序号]则可以代表列表中列表的第几个元素。
    4.元素存在个数
    list.count(参数名)
    5.元素的索引
    list.index(参数名,开始的序号,结束的序号) 结果将告诉你参数所在位置
    6.列表的翻转
    list.reverse()
    7.列表的排序
    list.sort() 默认从小到大重新排序 list.sort(reverse=True)则代表从大到小排序。
    注意:
    在这里插入图片描述
    切片后改变原列表时拷贝和赋值变化不同
    六、元组
    元组中的元素无法随意改变不同与列表,元组一般用小括号,但
    ‘小逗号’**才是元组的关键。
    在这里插入图片描述
    元组的添加与删除元素方法
    在这里插入图片描述
    del tuple 删除整个元组。

    展开全文
  • 主要介绍了Python列表与元组的异同详解,“列表(list)与元组(tuple)两种数据类型有哪些区别”这个问题在初级程序员面试中经常碰到,超出面试官预期的答案往往能加不少印象分,也会给后续面试顺利进行提供一定帮助,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,103
精华内容 3,241
关键字:

python列表与元组

python 订阅