精华内容
下载资源
问答
  • 修改元祖用
    千次阅读
    2019-09-26 10:37:57

    1.操作元组

    元组是不可变的序列。序列意味着它的元素是按索引位置有序的,序列的通用操作元组都可以使用,不可变序列意味着那些序列的修改行为都不能用,但是却可以使用hash()内置函数对元组进行hash。这里简单介绍一点基本操作。

    元组支持+ *符号操作:

    1 >>> T = (1,2,3,4)
    2 >>> T1 = ('a','b','c')
    3
    4 >>> T + T1
    5 (1, 2, 3, 4, 'a', 'b', 'c')
    6
    7 >>> (1,2) + tuple("34")
    8 (1, 2, '3', '4')
    9 
    10 >>> T * 2
    11 (1, 2, 3, 4, 1, 2, 3, 4)
    12 >>> 2 * T
    13 (1, 2, 3, 4, 1, 2, 3, 4)
    
    我是一名python开发工程师,整理了一套python的学习资料,从基础的python脚本到web开发、爬虫、
    数据分析、数据可视化、机器学习、面试真题等。想要的可以进群:688244617免费领取

    可以通过+=的方式进行二元赋值:

    1 >>> T1 = (1,2,3)
    2 >>> T2 = (4,5,6)
    3
    4 >>> T1 += T2
    5 >>> T1
    6 (1, 2, 3, 4, 5, 6)

    元组是序列,序列类型的每个元素都是按索引位置进行存放的,所以可以通过索引的方式取得元组中的各个元素,通过切片的方式取得子元组:

    1 >>> T = (1,2,3,4,5)
    2 >>> T[0]
    3 1
    4 
    5 >>> T[:3]
    6 (1, 2, 3)
    7 >>> T[:]
    8 (1, 2, 3, 4, 5)
    9 >>> T[2:-1]
    10 (3, 4)

    但不能赋值,因为元组是不可变对象。

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

    因为元组是不可变对象,所以可以使用hash()进行hash:

    1 >>> hash(T)
    2 -1883319094
    3 >>> hash((1,2,3))
    4 -378539185
    5 >>> hash([1,2,3])
    6 Traceback (most recent call last):
    7   File "<stdin>", line 1, in <module>
    8 TypeError: unhashable type: 'list'

    2.修改元组

    因为元组是不可变对象,所以没有直接方法修改元组,只能通过其它手段根据原始元组间接地构造新元组。切片返回的元组也是一种修改方式。

    另外,要修改元组,可以考虑将元组转换成可变的列表,修改之后再转换回元组。例如:

    1 >>> t = ('a','b','c','d')
    2 >>> tmp = list(t)
    3 >>> tmp[2] = "cc"
    4 >>> t = tuple(tmp)
    5 >>> t
    6 ('a', 'b', 'cc', 'd')

    或者,通过解析的方式构造新元组,但元组解析必须注意的是元组的括号特殊性,因为它会被当作表达式的包围括号,而不是元组的构造括号。所以,只能使用tuple()包围解析表达式。

    1 >>> T = (1,2,3,4,5)
    2 >>> tuple( i * 2 for i in T)
    3 (2, 4, 6, 8, 10)
    4
    5 >>> ( i * 2 for i in T)  # 不是元组,而是表达式括号
    6 <generator object <genexpr> at 0x03572150>

    觉得文章还可以的话不妨点个赞,有任何意见或者看法欢迎大家评论!

    更多相关内容
  • 因为元组具有不可变的特性,所以在能元组替代列表的地方最好都使用元组,这样代码更安全。 创建元组 元组创建很简单,只需要在括号()中添加元素,元素之间逗号隔开。元组中只包含单个元素时,需要在该元素后面...

    元组与列表

    元组与列表很相似,两者之间的差别在于,列表在初始化后其中的元素还可以进行增删改等操作,但是元组在初始化后其中的元素不能进行更改,列表在赋值时使用方括号[],而元组在赋值时使用小括号()。因为元组具有不可变的特性,所以在能用元组替代列表的地方最好都使用元组,这样代码更安全。

    创建元组

    元组创建很简单,只需要在括号()中添加元素,元素之间用逗号隔开。元组中只包含单个元素时,需要在该元素后面添加逗号,例如:

    menu1 = (‘meat’,‘fish’,‘chicken’)
    menu2 = (‘meat’,)

    访问元组
    元组和列表一样,可以使用下标索引来访问元组中的值,例如:

    menu = ('meat','fish','chicken','carrot')
    print(menu[0])
    print(menu[1:3])
    

    输出结果:

    meat
    (‘fish’, ‘chicken’)

    修改元组

    元组中的元素值是不可以修改的,如果强行修改会报错,例如如果我们想修改元组menu中的某个值:

    menu = ('meat','fish','chicken','carrot')
    menu[0] = 'pizza'
    print(menu[0])
    

    输出结果:

    TypeError: ‘tuple’ object does not support item assignment

    系统会自动报错,元组中的元素值不支持修改。

    元组内置函数

    元组和列表一样,都有一些内置函数方便编程。例如:

    len(tuple):计算元组中元素个数。

    max(tuple):返回元组中元素的最大值。

    min(tuple):返回元组中元素的最小值。

    tuple(seq):将列表转换为元组。

    元组中的元素是不能改变的,它也没有append(),insert()这样的方法。但其他获取元素的方法和列表是一样的。

    实现如下功能:

    将输入的菜单menu_list转换为元组类型

    打印输出生成的元组

    打印输出元组中首字母最大的元素

    代码:

    # coding=utf-8
    
    # 创建并初始化menu_list列表
    menu_list = []
    while True:
        try:
            food = input()
            menu_list.append(food)
        except:
            break
    
    # 请在此添加代码,对menu_list进行元组转换以及元组计算等操作,并打印输出元组及元组最大的元素
    ###### Begin ######
    #将输入的菜单menu_list转换为元组类型
    #元组名 = tuple(列表名)
    yuanzu = tuple(menu_list)
    #打印输出生成的元组
    #打印元祖里的元素方法跟打印列表里的元素方法一样,直接用print打印
    print(yuanzu)
    #打印输出元组中首字母最大的元素
    #打印元祖中首字母最大的元素直接用max函数:print(max(元祖名))
    print(max(yuanzu))
    #######  End #######
    
    展开全文
  • 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笔记: 元祖

    2020-12-20 22:21:06
    元祖内只有一个元素则类型为元素类型 #类型测试 t1 = (1) print(type(t1)) 运行结果: 注意:元组里面只能存元素,不能修改元素 使用tuple 把list转变成元组 #例子 list 转变为元组 list1 =['ac','av','ab','aw'...
  • #tup2=list(tup1) #想要修改元祖,必须先将其转换成list才可以 #print tup2 #打印结果:['physics', 'chemistry', 1997, 2000] #tup2[2] = '1989' #print tup2 #打印结果:['physics', 'chemistry', 1989, 2000] 2....

    一、定义列表

    1.names = ['mike','mark','candice','laular'] #定义列表

    2.num_list = list(range(1,10)) #range生成1-10范围内的数,并强制转化成列表

    二、增:append()、insert()方法

    1.append()方法:在末尾添加元素

    #szz = ['ab','jhj','nhy']

    #szz.append('msr')

    #szz打印结果:['ab', 'jhj', 'nhy', 'msr']

    2.insert()方法:在指定位置添加元素或者列表

    #szz = ['ab','jhj','nhy']

    #szz1 = ['msr','mike']

    #szz.insert(0,'mark') #szz打印结果['mark', 'ab', 'jhj', 'nhy']

    #szz.insert(0,szz1) #szz打印结果[['msr', 'mike'], 'ab', 'jhj', 'nhy']

    三、删:del、pop()、remove()、clear()

    1.del:可以删除指定下标的值

    #del szz[1] #删除下标为1的值

    2.pop()方法: #默认从列表的末尾删除,也可以删除指定的值

    #szz.pop() #默认删除末尾的值

    #szz.pop(1) #删除下标为1的值

    3.remove()方法:删除指定的值

    #szz =[['msr', 'mike'], 'ab', 'jhj', 'nhy']

    #szz.remove('jhj') #在原list中的可以直接删除

    #szz[0].remove('mike') #在另一个list里的需要定位到list才能删除,szz.remove('mike')这种方法是不能正确执行的,会报错ValueError: list.remove(x): x not in list

    4.clear()方法:清空数据

    #szz.clear() #清空列表数据,如果有嵌套list也直接清空,无需定位到嵌套的list再清空

    四、改:

    1.通过定位到下标直接修改

    #['mark', 'ab', 'jhj', 'nhy']

    #szz[1] = 'zzj'

    #print(szz) #打印结果:['mark', 'zzj', 'jhj', 'nhy']

    五、查:查询列表可通过下标和切片的方式

    1.下标取值,从0开始

    #names = ['mike','mark','candice','laular'] #定义列表

    #print(names[2]) #读取列表的值

    #num_list = list(range(1,10)) #range生成一个长度为10的列表

    #print(num_list) #打印结果:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    2.切片:顾头不顾尾,且切片下标的操作同样用于字符串

    #names = ['mike','mark','candice','laular']

    #info = 'abcdefghijklmn'

    #num_list = list(range(1,10))

    #print(names[1:3]) #通过切片方式取值,切片是顾头不顾尾,打印结果:['mark', 'candice']

    #print(names[1:]) #取下标后面所有的值,打印结果:['mark', 'candice', 'laular']

    #print(names[:3]) #取下标前面所有的值,打印结果:['mike', 'mark', 'candice']

    #print(names[:]) #取所有的值,打印结果:['mike', 'mark', 'candice', 'laular']

    #print(names[-1]) #取最后一个值,打印结果:laular

    #print(names[:1:2])#隔几位取一次,默认不写步长为1,即隔一位取一次;结果为取下标为1之前的值,隔2位取一个['mike']

    #print(num_list[::-1])#从后往前取值,步长为1,打印结果:['laular', 'candice', 'mark', 'mike']

    #print(info[1:7]) #打印结果:bcdefg

    六、列表其他方法:

    1.index()方法:获取指定元素的下标

    #szz.index('jhj')

    2.count()方法:获取指定元素的次数

    #szz.count('mike')

    3.extend()方法:合并列表,修改原列表的值,只能合并到原列表的末尾

    #szz = ['ab','jhj','nhy']

    #szz1 = ['msr','mike']

    #szz.extend(szz1) #打印结果:['ab', 'jhj', 'nhy', 'msr', 'mike']

    4.sort()方法:进行排序,默认是升序,想要降序排序需要加:reverse=True ,reverse返转的意思

    #sort本身只是一个方法,没有返回值,所以不能打印

    #numbs = [12,425,334,32]

    #numbs.sort()

    #print numbs #打印结果:[12, 32, 334, 425]

    #numbs.sort(reverse=True)

    #print numbs #打印结果:[425, 334, 32, 12]

    七、insert和extend的区别:

    1.insert可以指定插入元素的位置,extend不能指定,只能合并到末尾

    2.insert是在原列表的基础上增加元素,什么都可以加(列表、字符串……),extend只能合并2个列表,对列表进行扩展,不能添加字符串

    八、元祖

    1.元组的值,不能改变,是一个不可便的列表,可以通过访问下标和切片的方式查询,但是想要修改必须先转成list

    #tup1 = ('physics', 'chemistry', 1997, 2000)  #定义元祖

    #print tup1[1]   #打印结果:chemistry

    #tup1[0] = 100   #这种修改方式是非法的

    #tup2=list(tup1) #想要修改元祖,必须先将其转换成list才可以

    #print tup2      #打印结果:['physics', 'chemistry', 1997, 2000]

    #tup2[2] = '1989'

    #print tup2           #打印结果:['physics', 'chemistry', 1989, 2000]

    2.元祖只有count和index方法

    names = ('mike','mark','candice','laular','mark','msr')

    print(names.count('mark')) #打印结果:2

    print(names.index('msr')) #打印结果:5

    展开全文
  • 如下:tuple(元祖英文) 跟列表类似, 元素不能修改用于存储 一串信息,数据元祖使用 () 定义, 列表是使用 []定义元祖的索引是从0开始元祖是可以存储不同数据的.列表则不是,列表只能存储相同数据.元祖的语法:MyDataTuple...
  • 元祖和字典

    2021-03-16 02:13:59
    元祖的定义Tuple 元祖与列表类似,不同之处在于元祖中 元素不能修改元祖表示多个元素的序列元祖在python中,有特定的应用场景元祖用于存储 一串信息,数据之间用逗号分隔元祖用 ( ) 定义,与列表不一样,列表用方...
  • 元祖以及元祖使用

    2022-01-18 20:40:16
    元祖以及元祖使用 元祖和列表很像,都是用来保存多个数据 使用小括号 () 来表示一个元祖 元祖和列表的区别在于,列表是可变的,而元祖是不可变数据类型 words = ['hello', 'yes', 'good', 'hi'] # 列表,使用 [] ...
  • Python中元祖的用法

    2020-12-10 10:05:26
    元祖tuple(,)元祖就是不可变的列表,元祖用()表示,元素与元素之间用逗号隔开,数据类型没有限制。tu=('科比','詹姆斯','乔丹')tu=tuple('123')小括号中有一个元素,有逗号就是元祖,没有就是它本身。空的小括号就是元祖...
  •  元祖用()  字典:dict 注:所有的数据类型都存在想对应的类列里,元祖和列表功能一样,列表可以修改,元祖不能修改。 二.列表所有数据类型: 基本操作: 索引,切片,长度,包含,循环 class tuple(object): ...
  • Swift tuple 元祖 func

    2022-05-27 12:41:29
    Swift tuple 元祖 func
  • Python 中的数据结构是通过某种方式组织在一起的数据元素的集合,这些数据元素可以是数字、字符、甚至可以是其他数据结构在 Python 中,最基本的数据结构是...元组使用小括号(),列表使用方括号[]。元组基本操作1...
  • 列表 元祖 字典

    2020-02-05 20:53:00
    列表中的元素可以是任意数据类型,整型,浮点型,字符串类型,甚至可以是列表、元祖或者字典。 列表的操作: (1)可使用下标获取列表中的某个元素 ,例如 list1[0] (2)负数下标以及切片获取子列表 虽然下标...
  • Python 中的数据结构是通过某种方式组织在一起的数据元素的集合,这些数据元素可以是数字、...元组使用小括号(),列表使用方括号[]。 元组基本操作 1、元祖的创建 aTuple=(1,2,3) print(aTuple) >>>(1,2, 3)
  • 一、列表List(列表)是Python中使用最频繁的数据类型,列表[]标识。a.列表可以包含任意内容:它支持数字,字符,字符串甚至可以包含列表,(即嵌套)b.列表中的值的切割也可以用到变量[头下标:尾下标],就可以截取...
  • 需求:8位老师,3个办公室,将8位老师随机...元组特点:定义元组使用小括号,且逗号隔开各个数据,数据可以是不同的数据类型。 运行结果: 注意:如果定义的元组只有一个数据,那么这个数据后面也要添加逗号,否则
  • 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"}]#列表里面可以存放数字...
  • 一、元祖 1、简介 Python的元组与列表类似,...3、元祖使用场景 当我们希望数据不改变时,就使用元组,其余情况都使用列表 二、元祖的创建 使用()来创建元组 my_tuple = (1, 2, 3, 4, 5) # my_tuple[2] = 10 # TypeErro
  • python学习第七讲,python中的数据类型,列表,元祖,字典,之元祖使用与介绍 目录 python学习第七讲,python中的数据类型,列表,元祖,字典,之元祖使用与介绍 一丶元祖 1.元祖简介 2.元祖变量的定义 3.元祖变量的常用操作....
  • Scala:元祖使用

    2020-06-28 12:24:35
    1.声明 当前内容主要用于本人学习和复习,当前的内容主要为元祖使用 当前内容借鉴:菜鸟教程 2.元祖使用 1.创建元祖: ... // 元祖类型的数据一旦创建就不可以改变,不能添加和修改数据了 var tuple2 =
  • listpython内置的一种数据...比如,列出班里所有同学的名字,就可以一个list表示:>>> classmates = ['michael', 'bob', 'tracy']>>> classmates['michael', 'bob', 'tracy']变量classmates就...
  • python遍历元祖

    2020-11-28 18:18:21
    例如:()#求长度,len()函数可以用于获得元祖的长度。 #合并,加法运算可用于合并多个元祖。 (1,2)+(abc,bbd)+(2,45)#重复,乘法运算可用于合并多个重复的元祖。 dd=(1,2)*3print(dd)#迭代,可用于迭代遍历元祖中的...
  • 1.list有序,元素可以被修改li=[1,2,2,"am","123"]列表中的元素可以是数字,字符串,列表等等支持切片,切片结果为列表 li[3],li[3:-1]修改 li[2]=3 li[1:3]=[120,90]删除 del li[1] del[3:5],包前不包后in操作,判断一个...
  • Python列表和元祖

    2020-12-17 23:35:00
    Python的数据结构有 序列和容器(容器包含序列、映射、集合)Python包含6种内建的序列:列表、元祖、字符串、Unicode字符串、buffer对象、xrange对象。最基本的数据结构是序列(元祖和列表),序列中所有元素都是有编号...
  • JAVA里的元祖

    2021-02-12 11:58:30
    什么是元祖类java中的方法只能返回单个对象,如果需要返回多个怎么办?通常我们会创建一个额外的对象,或者把返回内容放入集合中返回,另外,我们也有其他的选择:结合泛型,我们可以把一组对象直接打包存储于单一...
  • python 元祖简介

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

    2019-01-06 12:00:00
    元祖:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改. 一个不可修改的列表 tuple tu = () 不可...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,320
精华内容 7,328
热门标签
关键字:

修改元祖用