精华内容
下载资源
问答
  • python元祖修改
    2021-09-16 11:46:50

    python元祖

    即使再小的帆也能远航~

    一,目录

    元组的定义

    元组的创建

    访问元组中的值

    更新元组

    删除元组元素

    基本元组操作

    索引,切片和矩阵

    元组 循环遍历

    元组应用场景

    元组和格式化字符串

    元组和列表之间的转换

    内置元组函数功能

    二.内容

    元组的定义

    [笛卡尔积]中每一个素(d1,d2,…,dn),叫作一个n元组(n-tuple)或简称元组。当关系是一张表,二维表中的行表中的每行(即中的每条记录)就是一个元组,每列就是一个属性。在二维表里,元组也称为记录。

    元组是一系列不可变的Python对象。元组是一种序列,就像列表一样。元组和列表之间的主要区别是元组不能像列表那样改变元素的值,可以简单地理解为“只读列表”。 元组使用小括号 - (),而列表使用方括号 -[]

    • 列表通常用来存储相同类型的数据;而元组在实际开发中,通常用来存储不同类型的数据。
    • 元组(Tuple)与列表相似,不同之处在于元组的元素不能修改;
    • 元组表示多个元素组成的序列;用于存储一串信息,不同数据之间用逗号隔开;
    • 元组的索引从0开始;

    元组的定义语法

    变量名 = (数据1, 数据2, 数据3...)
    eg:
    uesr_tuple = ("zhangsan", "lisi", "wangwu")
    

    元组中各元素之间用逗号隔开。元组不支持修改或删除其所包含的元素。

    如果要修改,则可以使用list函数把它转化成列表,然后在列表上进行修改创建元组的方法有三种:

    1、使用括弧“0”来创建,例如,a=(1,2,3);

    2、使用逗号来创建,例如,b=2,4;

    3、使用 tuple0函数把其他种类的序列转化为元组,例如,c= tuple(“Good!”)。 [3]

    元组的创建

    创建一个元组只需使用逗号分隔值放入小括号的一个序列。 或者,也可以将这些逗号分隔值放在括号之间。 例如 -

    tup1 = ('physics', 'chemistry', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5 )
    tup3 = "a", "b", "c", "d"
    Python
    

    空的元组写成两个不含任何东西的小括号 -

    tup1 = ();
    Python
    

    要编写一个包含单个值的元组,必须包含一个逗号,即使只有一个值(这是规范写法) -

    tup1 = (50,)
    ## 也可以这样写
    tup2 = (50)
    Python
    

    访问元组中的值

    要访问元组中的值,请使用方括号进行指定索引切片或索引,以获取该索引处的值。 例如 -

    #!/usr/bin/python3
    
    tup1 = ('physics', 'chemistry', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5, 6, 7 )
    
    print ("tup1[0]: ", tup1[0])
    print ("tup2[1:5]: ", tup2[1:5])
    Shell
    

    当执行上述代码时,会产生以下结果 -

    tup1[0]:  physics
    tup2[1:5]:  (2, 3, 4, 5)
    Python
    
    # 定义空元组;
    
    empty_tuple = ()
    type(empty_tuple)  # tuple
    
    # 定义一个单元素元组;
    
    # 如果元组中只有一个数据,要在那一个数据后面加逗号,否则该元组变量会被python解释器认为是括号内数据的数据类型;
    
    single_tuple = (5)
    type(single_tuple)  # int
    single_tuple = (5,)
    type(single_tuple)  # tuple
    

    更新元组

    元组是不可变的,这意味着我们无法更新或更改元组元素的值。 但是可以使用现有元组的一部分来创建新的元组,如下例所示:

    #!/usr/bin/python3
    
    tup1 = (12, 34.56)
    tup2 = ('abc', 'xyz')
    
    # Following action is not valid for tuples
    # tup1[0] = 100;
    
    # So let's create a new tuple as follows
    tup3 = tup1 + tup2
    print (tup3)
    Python
    

    当执行上述代码时,会产生以下结果 -

    (12, 34.56, 'abc', 'xyz')
    Shell
    

    删除元组元素

    删除单个元组元素是不可能的。 当然,将不必要的元素放在另一个元组中也没有什么错。

    要显式删除整个元组,只需使用del语句。 例如 -

    #!/usr/bin/python3
    
    tup = ('physics', 'chemistry', 1997, 2000);
    
    print (tup)
    del tup;
    print "After deleting tup : "
    print (tup)
    Python
    

    执行上面代码,将产生以下结果 -

    注 - 引发异常。这是因为在del tup之后,元组不再存在。

    ('physics', 'chemistry', 1997, 2000)
    After deleting tup :
    Traceback (most recent call last):
       File "test.py", line 9, in <module>
          print tup;
    NameError: name 'tup' is not defined
    Shell
    

    基本元组操作

    元组响应+*运算符很像字符串; 它们执行连接和重复操作,但结果是一个新的元组,而不是一个字符串。

    事实上,元组中类似字符串操作和使用的所有常规序列操作都有作了讲解。

    Python表达式结果描述
    len((1, 2, 3))3长度
    (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, end = ' ') |1 2 3`迭代

    索引,切片和矩阵

    由于元组是序列,索引和切片的工作方式与列表的工作方式相同,假设输入以下值:

    T=('C++', 'Java', 'Python')
    Python
    

    那么 -

    Python表达式结果
    T[2]'Python'偏移量,从零开始
    T[-2]'Java'负数:从右到左
    T[1:]('Java', 'Python')切片提取部分

    元组 循环遍历

    元组遍历就是 从头到尾 依次从元组中取数据;
    每次循环都将 从元组中顺序的读取出来的数据放在临时变量中,然后执行相同的操作。
    使用for进行迭代遍历。

    user_tuple = ["zhangsan", 20, 181]
    for i in user_tuple:
    #因为通常元组的元素数据类型不同,所以一般很少遍历元组做操作,
        # 除非确定元组中每一个元素的数据类型
        print(i)
    

    在Python中,可以使用for循环遍历所有非数字型类型的变量:列表,元组,字典以及字符串

    元组应用场景

    • 函数的参数和返回值;一个函数可以接收任意多个参数,或者一次返回多个数据。
    • 格式字符串,格式化字符串后面的()本质上就是一个元组。
    • 保护数据安全,列表不能被修改。

    元组和格式化字符串

    格式化后面的括号和内容,本质上就是元组;我们可以先定义一个元组,然后在格式化后面%元组,一样能输出;
    同时,我们甚至可以将print括号里面的函数拿出来,定义成一个变量,再用print输出

    # 四者的输出结果都一样
    # zhangsan 的年龄是 20, 身高是 181
    name = "zhangsan"
    age = 20
    height = 181
    print("%s 的年龄是 %d, 身高是 %d" % (name, age, height))
    
    userinfo = ("zhangsan", 20, 181)
    
    print("%s 的年龄是 %d, 身高是 %d" % (userinfo[0], userinfo[1], userinfo[2]))
    
    # 也可以这样玩
    print("%s 的年龄是 %d, 身高是 %d" % userinfo)
    
    # 还可以这样玩
    info = "%s 的年龄是 %d, 身高是 %d" % userinfo
    print(info)
    

    元组和列表之间的转换

    元组转列表:list()
    列表转元组:tuple()

    num_list = [2,1,4,3]
    type(num_list)  # list
    
    num_tuple = tuple(num_list)
    type(num_tuple)  # tuple
    
    num_list2 = list(num_tuple)
    type(num_list2)  # list
    

    内置元组函数功能

    Python包括以下元组函数 -

    编号函数描述
    1cmp(tuple1, tuple2)比较两个元组的元素。
    2len(tuple)给出元组的总长度。
    3max(tuple)从元组返回最大值项。
    4min(tuple)从元组返回最大值项
    5tuple(seq)将列表转换为元组。
    更多相关内容
  • Python元祖(tuple)修改元素教程通过追加的方式来修改原来的元祖,追加的元素只能是元祖类型的,不能是其他任何类型的。Python元祖(tuple)赋值修改元素详解语法tup = (element1, element2)tup = (element3, element4)...

    Python元祖(tuple)修改元素教程

    通过追加的方式来修改原来的元祖,追加的元素只能是元祖类型的,不能是其他任何类型的。

    Python元祖(tuple)赋值修改元素详解

    语法

    tup = (element1, element2)

    tup = (element3, element4)

    参数

    参数

    描述

    element1, element2

    原元祖的元素。

    tup

    需要被修改的元祖。

    element3, element4

    需要设置的新元祖的值。

    说明

    我们通过对整个元祖赋值的方式,将元祖 tup 的所有的元素由原来的 element1 和 element2,直接赋值修改为了 element3 和 element4。

    Python元祖(tuple)追加修改元素详解

    语法

    tup = (element1, element2)

    tup = tup + (element3, element4)

    参数

    参数

    描述

    element1, element2

    原元祖的元素。

    tup

    需要被修改的元祖。

    element3, element4

    需要追加的元祖的值。

    说明

    我们通过对原来的元祖 tup 追加了两个元素 element3 和 element4 然后再将修改后的元祖赋值给原来元祖的方式,来修改元祖中的元素。

    案例

    赋值修改元祖元素

    通过对整个元祖赋值的方式,修改原来元祖的数据

    print("嗨客网(www.haicoder.net)")

    # 通过对整个元祖赋值的方式,修改原来元祖的数据

    tup = ("Hello", "HaiCoder", 1024)

    print("Before =", tup)

    tup = ("嗨客网", "Python")

    print("After =", tup)

    程序运行后,控制台输出如下:

    我们使用 () 创建了一个元祖 tup,元祖的第一个和第二个元素都是

    接着,我们使用整个元祖赋值的方式,修改了整个元素中的元素,最后我们打印修改前和修改后的元祖,发现,整个元祖的元素都被修改了。

    追加修改元祖元素

    通过对整个元祖追加元素再次赋值的方式,修改原来元祖的数据

    print("嗨客网(www.haicoder.net)")

    # 通过对整个元祖追加元素再次赋值的方式,修改原来元祖的数据

    tup = ("Hello", "HaiCoder", 1024)

    print("Before =", tup)

    tup = tup + ("嗨客网", "Python")

    print("After =", tup)

    程序运行后,控制台输出如下:

    我们使用 () 创建了一个元祖 tup,该元祖有三个元素,接着,我们使用 + 号,在该元素后面增加了两个元素,再次赋值给原来的元祖,通过这样的方式修改了整个元素中的元素。

    最后我们打印修改前和修改后的元祖,发现,修改后的元祖的元素增加了两个,即元祖被修改了。

    追加修改元祖元素

    通过追加元素的方式,修改元祖的数据,只能追加元祖,不能是列表

    print("嗨客网(www.haicoder.net)")

    # 通过追加元素的方式,修改元祖的数据,只能追加元祖,不能是列表

    tup = ("Hello", "HaiCoder", 1024)

    print("Before =", tup)

    tup = tup + ["嗨客网", "Python"]

    print("After =", tup)

    程序运行后,控制台输出如下:

    我们使用 () 创建了一个元祖 tup,该元祖有三个元素,接着,我们使用 + 号,在该元素后面增加了一个

    追加修改元祖元素

    通过追加元素的方式,修改元祖的数据,只能追加元祖,不能是字符串

    print("嗨客网(www.haicoder.net)")

    # 通过追加元素的方式,修改元祖的数据,只能追加元祖,不能是字符串

    tup = ("Hello", "HaiCoder", 1024)

    print("Before =", tup)

    tup = tup + ("嗨客网")

    print("After =", tup)

    程序运行后,控制台输出如下:

    我们使用 () 创建了一个元祖 tup,该元祖有三个元素,接着,我们使用 + 号,在该元素后面增加了一个字符串,再次赋值给原来的元祖,最终程序报错,说明追加的元素不可以是字符串。

    这里虽然是使用了 () 加上字符串的形式,但这个只是字符串,不是元祖,我们如果 () 里面只有一个元素,想要定义成元祖,那么一个元素的后面必须要加逗号。

    Python元祖(tuple)修改元素总结

    Python 中的元祖是一个不可变的序列,因此我们不可以对元祖的元素进行单独的修改,但是我们可以通过对元祖重新赋值的方式或者将整个元祖加上一个新的元祖再赋值给原来元祖的方式对整个元祖进行修改。

    通过追加的方式来修改原来的元祖,追加的元素只能是元祖类型的,不能是其他任何类型的。Python 元祖(tuple)赋值修改元素语法:

    tup = (element1, element2)

    tup = (element3, element4)

    Python 元祖(tuple)追加修改元素语法:

    tup = (element1, element2)

    tup = tup + (element3, element4)

    展开全文
  • python 元祖--字典

    2022-05-05 16:45:30
    1、元祖的格式(tuple类型) tuples = (1,2,3,4,5,6,7) 2、访问元祖 通过索引取数据 # 案例:索引值存在 aTuple=(23,35,56,34,11,21) print(aTuple[2]) 索引值:56 # 案例:索引值不存在 aTuple=(23,35,56,34,11,21) ...

    1、元祖的格式(tuple类型)

    tuples = (1,2,3,4,5,6,7)
    

    2、访问元祖

    通过索引取数据

    # 案例:索引值存在
    aTuple=(23,35,56,34,11,21)
    print(aTuple[2])
    索引值:56
    
    # 案例:索引值不存在
    aTuple=(23,35,56,34,11,21)
    print(aTuple[20])
    IndexError: tuple index out of range
    

    3、查询个数

    count查询出现的个数

    # 案例:
    aTuple=('b','c','d','e','f','g')
    print(aTuple.count('d'))
    1
    

    4、查询索引

    index:查询元素的索引,有对应的元素返回对应的索引,否则报错

    # 案例:有对应的元素
    aTuple=('b','c','d','e','f','g')
    print(aTuple.index('d',0,4))
    2
    
    # 案例:无对应的元素
    aTuple=('b','c','d','e','f','g')
    print(aTuple.index('d',0,1))
    ValueError: tuple.index(x): x not in tuple
    

    5、修改数据(不能修改)

    修改数据会报错

    # 案例:
    aTuple=('b','c','d','e','f','g')
    aTuple[1]=23
    TypeError: 'tuple' object does not support item assignment
    

    6、类型转换

    列表转换元组

    # 案例:
    aa = [23,34,45,56,67]
    print(tuple(aa))
    (23, 34, 45, 56, 67)
    

    7、元组的循环取值

    # 方式一:for循环
    aTuple=('b','c','d','e','f','g')
    for i in aTuple:
    print(i)
    

    字典

    1、字典的格式

    以键值对的形式为字典

    info = {"name":"chuyi","age":12,"sex":"男"}
    字典的每个元素由2部分组成,键(key):值(value)
    

    2、根据键访问值

    # 案例:有对应key的
    info = {"name":"chuyi","age":12,"sex":"男"}
    print(info["name"])
    chuyi
    
    # 案例:无对应key的
    info = {"name":"chuyi","age":12,"sex":"男"}
    print(info["name12"])
    KeyError: 'name12'
    

    3、修改元素

    字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改,否则是新增

    # 案例:有对应的key
    info = {"name":"chuyi","age":12,"sex":"男"}
    info["age"] =14
    print(info)
    {'name': 'chuyi', 'age': 14, 'sex': '男'}
    
    # 案例:无对应的key
    info = {"name":"chuyi","age":12,"sex":"男"}
    info["gender"] ="属鸡"
    print(info)
    {'name': 'chuyi', 'age': 12, 'sex': '男', 'gender': '属鸡'}
    

    总结:有对应的key则是修改数据,没有对应的key是新增数据

    4、添加元素

    # 案例:
    info = {"name":"chuyi","age":12,"sex":"男"}
    info["gender"] ="属鸡"
    print(info)
    {'name': 'chuyi', 'age': 12, 'sex': '男', 'gender': '属鸡'}
    

    5、删除元素

    清空数据 del.clear()

    # 案例:删除某个元素
    info = {"name":"chuyi","age":12,"sex":"男"}
    del info["name"]
    print(info)
    {'age': 12, 'sex': '男'}
    

    6、查询长度

    len():查询键值对的个数

    # 案例:
    info = {"name":"chuyi","age":12,"sex":"男"}
    print(len(info))
    3
    

    7、字典中循环

    # 案例:取出字典中的key
    info = {"name":"chuyi","age":12,"sex":"男"}
    for i in info.keys():
    print(i)
    chuyi age sex
    
    # 案例:取出字典中的value
    info = {"name":"chuyi","age":12,"sex":"男"}
    for i in info.values():
    print(i)
    chuyi 12

    取出字典中的key和value

    # 案例1:
    info = {"name":"chuyi","age":12,"sex":"男"}
    for i in info.keys():
        print(i,info[i])
    
    # 案例2:
    info = {"name":"chuyi","age":12,"sex":"男"}
    for k,v in info.items():
    print(k,v)
    

    8、扩充

    # enumerate()实现索引的遍历
    names=["chuyi","tom","meachal"]
    for i,chr in enumerate(names):
    print(i,chr)
    

    返回值
    0 chuyi
    1 tom
    2 meachal

    展开全文
  • python 元祖简介

    千次阅读 2020-03-21 10:09:24
    与列表(list)非常类似,只不过元祖不能在远处进行修改,通常用圆括号表示。 1、元祖的常见运算 # 创建一个空元祖 >>> t = () >>> type(t) <class 'tuple'> # 创建一个单元素的元祖,注意...

    元祖(tuple)是python独有的一类对象。与列表(list)非常类似,只不过元祖不能在远处进行修改,通常用圆括号表示。
    1、元祖的常见运算

    # 创建一个空元祖
    >>> t = ()
    >>> type(t)
    <class 'tuple'>
    
    # 创建一个单元素的元祖,注意后面的逗号
    # 如果没有逗号,Python将会认为是int
    >>> t = (0,)
    
    # 多个元素
    >>> t = (0, 'Ni', 1.2, 3)
    
    # 不带圆括号也可以,但为了可读性建议带上
    >>> t = 0,
    >>> type(t)
    <class 'tuple'>
    
    # 通过tuple函数创建一个元祖
    >>> t = tuple('spam')
    >>> t
    ('s', 'p', 'a', 'm')
    
    # 通过索引分片获取元祖元素
    >>> t[2]
    'a'
    >>> t[1:3]
    ('p', 'a')
    
    # 获取元祖长度
    >>> len(t)
    4
    
    # 尝试对元祖元素修改会报错
    >>> t[2] = 'p'
    Traceback (most recent call last):
      File "<pyshell#11>", line 1, in <module>
        t[2] = 'p'
    TypeError: 'tuple' object does not support item assignment
    
    # 元祖的for循环和列表解析
    >>> for x in t:
    	print(x, end=' ')
    s p a m 
    >>> [x * 2 for x in t]
    ['ss', 'pp', 'aa', 'mm']
    
    # 查找与计算
    >>> t.index('s')
    0
    >>> t.count('s')
    1
    

    2、元祖与列表的转换

    >>> t = ('cc', 'aa', 'dd', 'bb')
    >>> tmp = list(t)
    >>> tmp.sort()
    >>> tmp
    ['aa', 'bb', 'cc', 'dd']
    >>> t = tuple(tmp)
    >>> t
    ('aa', 'bb', 'cc', 'dd')
    

    3、元祖的不可变性指的是顶层不可变性

    >>> t = (1, [2, 3], 4)
    # 直接修改会报错
    >>> t[1] = 'spam'
    Traceback (most recent call last):
      File "<pyshell#30>", line 1, in <module>
        t[1] = 'spam'
    TypeError: 'tuple' object does not support item assignment
    
    # 取出以后修改不会报错,因为list是可变的
    >>> t[1][0] = 'spam'
    >>> t
    (1, ['spam', 3], 4)
    

    哈哈,以上就是python小工具关于元祖的简介,出自
    《python学习手册》第九章,有兴趣的话欢迎关注公众号:python小工具。获取相关资料。
    在这里插入图片描述

    展开全文
  • python元祖

    2021-01-12 02:19:53
    1.认识元祖1.什么是元祖使用()将多个元素括起来,多个之间用逗号隔开。a.容器,可以同时存储多个数据,不可变的,有序不可变 --->不能增删改有序 --->可以通过下标获取元素b.元素:可以是任何数据注意:如果...
  • Python 元祖的用法

    千次阅读 2022-05-05 21:43:53
    不可变是指一但创建,不可以再添加/删除/修改元素. 列表:预留空间 元组:按需分配 基础操作 创建空元组: 元组名 = () 元组名 = tuple() # 1. 创建 tuple01 = (4, 54, 5, 6, 7) list01 = [3, 4, 5, 6] # 预留空间...
  • Python 中的数据结构是通过某种方式组织在一起...这个序号叫索引,索引下标从0开始,以此类推......Python 的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号(),列表使用方括号[]。元组基本操作1...
  • Python元祖总结

    2021-12-22 11:26:21
    元组 Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。 <1>访问元组 <2>修改元组 说明: python中不允许修改元组的数据,包括不能删除其中的元素。 &...
  • python元祖基本操作

    2020-12-04 12:58:17
    #-*- coding:utf-8 -*-# 创建空元组# temp1 = ();# 如果元祖中只包含一个值,需用逗号隔开消除歧义# temp1=(1,)# 元祖的基本操作# 访问元祖,可以使用下标索引访问元素的值# temp1=('hello','world')# ...#修改元祖#...
  • Python基础(元祖,集合) 一,什么是元祖 元祖 Python内置的数据结构之一,是一个不可变序列 不可变序列与可变序列 不可变序列:字符串、元祖 不可变序列特点:没有增、删、改的操作 可变序列:列表、...
  • 面试python遇到的一道数据类型基础题我们都知道python中不可变类型有tuple,但是如果tuple里面的列表增加元素会怎么样呢?先看代码:a = (1,2,3,[4,5])print(a[3]) # [4, 5]a[3].append(6)print(a) # (1, 2, 3, [4, 5, ...
  • Python的元组与列表类似,不同之处在于元组的元素不能修改。 所以在操作元组时,就把元组当成是一个不可变的列表就ok了。 2、元祖特点 1、元祖是一个不可变的序列 2、当元祖不是空元祖时,括号可以省略。 3、当元祖...
  • 注意点: python中不允许修改元组的数据,包括不能删除其中的元素。 2.元祖的内置函数 count , index count和index与字符串和列表中的用法相同 index: 举例: a=(“a”,“b”,“c”,“a”,“b”) print(a.index(‘a’,...
  • Python_列表与元祖

    2021-02-03 02:06:55
    #列表与元祖#列表的定义list1=[10,20,30,40,50,60]#列表里面的元素可以为纯数字list2=["a","b","c","d","e","f"]#列表里面的元素可以为纯字符串list3=["a",10,(1,2,3),[4,5,6],{"a":"apple"}]#列表里面可以存放数字...
  • Python元祖,字典

    2021-09-24 18:34:46
    Python的元组与列表类似,不同之处在于元组的元素不能修改。 元组使用小括号,列表使用方括号。 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。 1.定义一个元组 2.创建一个空元组 tup1 = ()...
  • python 元祖_字典

    2020-10-11 17:32:10
    tuple与list类似,不同之处在于tuple的元素不能修改。tuple写在小括号里,元素之间用逗号隔开。 元祖的元素不可变,但可以包含可变对象,如list。 注意:定义一个只有1个元素的tuple,必须加逗号。 ...
  • 元祖python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。 <1>访问元组 <2>修改元组 说明:python中不允许修改元组的数据,包括不能删除其中的元素。 <3&...
  • 1.字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单,只要为变量分配一个值即可。例如:var1 = 'Hello World!'2.列表是最常用的Python数据类型,它可以作为一个方括号内...
  • python修改元组的方法

    千次阅读 2020-10-08 22:28:04
    元组不能被修改,这是对的。 但是你要是非得霸王硬上弓,也是可以修改的。 首先,你要把元组转化为一个集合。 eg: a = (1,2,3) 此时a是一个元组 b = list(a) b [1,2,3] 此时b是一个集合 修改一个值,假如...
  • 文章目录元祖理解创建元祖可变对象 元祖理解 元祖是不可变序列:tuple 元祖的操作基本是和列表一致的,当操作元祖的时候可以把元祖当做不可变的列表一样 应用场景 当我们希望数据不可变时,可以使用元祖。有点...
  • Python 中的数据结构是通过某种...Python 的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号(),列表使用方括号[]。 元组基本操作 1、元祖的创建 aTuple=(1,2,3) print(aTuple) >>>(1,2, 3)
  • 定义 方法 列表 可以包含不同类型的...删除集合s中得任意一个对象,并返回它 s.clear():删除集合s中的所有元素 以上就是小编为大家带来的关于Python元祖,列表,字典,集合的比较全部内容了,希望大家多多支持聚米学院~
  • python元祖和文件用法举例

    千次阅读 2020-12-30 09:57:48
    use line 文件迭代器一行一行的读 open('f.txt',encoding='latin-1') #python3.0Unicode文本文件 open('f.txt','rb') #python3.0二进制文件 open('f.txt','rb') 4、文件的集中打开模式,r(读)...
  • 列表是一个可修改的,元素以逗号分割,以中括号包围的有序序列。 格式: 变量名=[元素1,元素2,元素3,…] 2.列表序列操作 由于列表是序列的一种,列表支持所有的我们对字符串所讨论过的序列操作。唯 的区别就是其...
  • python遍历元祖

    2020-11-28 18:18:21
    例如:()#求长度,len()函数可以用于获得元祖的长度。 #合并,加法运算可用于合并多个元祖。 (1,2)+(abc,bbd)+(2,45)#重复,乘法运算可用于合并多个重复的元祖。 dd=(1,2)*3print(dd)#迭代,可用于迭代遍历元祖中的...
  • 效率比工厂要好 方法(仅适用于可变集合):以下方法参数必须是可哈希的 s.update(t):用t中的元素修改s,即s现在包含s或t的成员 s.intersection_update(t):s中的成员是共同属于s和t的元素 s.difference_update(t)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,516
精华内容 6,606
关键字:

python元祖修改