精华内容
下载资源
问答
  • 主要介绍了C++ tuple元组的基本用法(总结),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 本文实例讲述了Python数据类型之Tuple元组。分享给大家供大家参考,具体如下: tuple元组 1.概述 本质上是一种有序的集合,和列表非常的相似,列表使用[]表示,元组使用()表示. 特点:一旦初始化,就不能发生改变 2....
  • tuple元组

    2020-07-08 22:48:01
    tuple元组tuple元组1、概述2、元组的创建3、元组元素的访问3.1 访问元组中的元素:3.2 修改元组3.3 删除元组4、元组操作4.1 元组连接组合4.2 元组重复4.3 判断元素是否在元组中4.4 元组的截取5、元组的方法5.1 len...

    tuple元组

    1、概述

    本质上是一种有序的集合,和列表非常的相似,列表使用[]表示,元组使用()表示

    特点:一旦初始化,就不能发生改变

    2、元组的创建

    格式:

    元组名 = (元素1, 元素2 ,元素3,…)

    #创建空的元组
    tuple1 = ()
    print(tuple1)
    #创建带有元素的元组
    tuple2 =(22, 33, 14, 109)
    print(tuple2)
    
    #与列表类似,元组中的元素类型可以不同
    tuple3 = (23True"good")
    print(tuple3)
    
    #定义只有一个元素的元组
    tuple4 = (1)  #这定义的不是元组而是整数1
    tuple4 = (1,) #定义一个元素的元组定义时必须加一个逗号",",用来消除歧义
    

    3、元组元素的访问

    3.1 访问元组中的元素:

    格式: 元组名[下标]

    tuple1 = (2040201401)
    print(tuple1[0])
    #注意使用下标取值的时候,要注意下标的取值范围,不要下标越界
    #获取最后一个元素
    print(tuple1[-1])
    

    3.2 修改元组

    在元组定义的时候大家都知道元组一旦初始化就不能改变,但是现在如果我想改变元组怎么办呢?

    元组是不能修改的,但是列表可以,元组中的元素的数据类型可以是不同类型的,因此我们可以通过在元组中添加一个列表,而列表是可以修改的,进而来”修改“我们的元组

    tuple1 = ('hello', 'you',[20, 30])
    #修改元组
    tuple1[0] = 'hi' 
    #报错,元组不能修改
    tuple1[2][1] = 'good'
    

    注意:从表面上看我们的元组确实是改变了,但其实改变的不是我们的元组,而是list的元素,所谓的tuple不变是说,tuple的每个元素的指向永远不变,一旦它指向了这个list,就不能改指向其他的对象,但是指向的list本身是可变的!

    3.3 删除元组

    元组是不可变的,但是我们可以使用del语句删除整个元组

    tuple1 = ('hello', 'hi')
    del tuple1
    print(tuple1)
    #此时会报错
    

    4、元组操作

    4.1 元组连接组合

    语法:

    元组1 元组2

    元组3 = 元组1 + 元组2

    tuple1 = (1,  2, 3)
    tuple2 = (4, 5, 6)
    print(tuple1 + tuple2)
    #结果
    (1, 2, 3, 4, 5, 6)
    

    注意:元素连接组合并没有改变原来的元组,而是生成了一个新的元组。

    4.2 元组重复

    语法:

    元组2 = 元组1 * n

    tuple1 = (1,  2, 3)
    tuple2 = tuple1 * 3
    print(tuple2)
    #结果
    (1, 2, 3, 1, 2, 3, 1, 2, 3)
    

    4.3 判断元素是否在元组中

    语法:

    元素 in 元组

    若存在则返回True,否则返回False

    tuple1 = (1,  2, 3)
    print( 1 in tuple1)
    #结果
    True
    
    tuple1 = (1,  2, 3)
    print( 5 in tuple1)
    #结果
    False
    

    4.4 元组的截取

    语法:

    元组名[start:end]

    截取的元组范围[start,end)

    功能:获取开始下标到结束下标之前的所有元素。

    若不指定start则默认是从开头开始截取到指定位置

    若不指定end则默认从指定位置截取到结尾

    tuple1 = (1,  2, 3, 8, 'hello', 'good')
    tuple2 = tuple1[2:5]
    print(tuple2)
    #结果
    (3, 8, 'hello')
    
    tuple1 = (1,  2, 3, 8, 'hello', 'good')
    tuple2 = tuple1[:5]
    print(tuple2)
    #结果
    (1, 2, 3, 8, 'hello')
    
    tuple1 = (1,  2, 3, 8, 'hello', 'good')
    tuple2 = tuple1[3:]
    print(tuple2)
    #结果
    (8, 'hello', 'good')
    

    5、元组的方法

    5.1 len(tuple)

    功能:获取元组元素的个数

    tuple1 = (1,  2, 3, 8, 'hello', 'good')
    print(len(tuple1))
    #结果
    6
    

    5.2 max(tuple)

    功能:获取元组中元素的最大值

    tuple1 = (1,  2, 3, 8, 20, 13)
    print(max(tuple1))
    #结果
    20
    

    5.3 min(tuple)

    功能:获取元组中元素的最小值

    tuple1 = (1,  2, 3, 8, 20, 13)
    print(min(tuple1))
    #结果
    1
    

    5.4 tuple(list)

    功能:将列表转换为元组

    list1 = [1,  2, 3, 8, 20, 13]
    print(tuple(list1))
    #结果
    (1, 2, 3, 8, 20, 13)
    

    6、二维元组

    与二维列表类似,一个元组中的元素依然是元组,则成为二维元组。

    元组名 =(元组1,元组2,…)

    tuple1 = ((1, 2, 3),(4, 5, 6),(7, 8, 9))
    

    二维元组取值

    元组名[下标1]【下标2】

    tuple1 = ((1, 2, 3),(4, 5, 6),(7, 8, 9))
    #获取第一个元组的第一个元素
    print(tuple1[0][0])
    #结果
    1
    
    展开全文
  • Tuple是.NET 4.0的新特性,主要功能是动态返回数据结构,也可以用做临时数据结构。现在有了元组[Tuple],看看它怎么用
  • 主要介绍了Python中的tuple元组详细介绍,本文讲解了Tuple 与 list 的相同之处、Tuple 不存在的方法、用 Tuple 的好处、Tuple 与 list 的转换等内容,需要的朋友可以参考下
  • Python tuple元组详解

    2019-08-13 17:21:28
    元组是 Python中另一个重要的序列结构,和列表类似,也是由一系列按特定顺序排序的元素组成。和列表不同的是,列表可以任意操作元素,是可变序列;而元组是不可变序列,即元组中的元素不可以单独修改。 元组可以...

    元组是 Python 中另一个重要的序列结构,和列表类似,也是由一系列按特定顺序排序的元素组成。和列表不同的是,列表可以任意操作元素,是可变序列;而元组是不可变序列,即元组中的元素不可以单独修改。

    元组可以看做是不可变的列表。通常情况下,元组用于保存不可修改的内容。


    从形式上看,元组的所有元素都放在一对小括号“()”中,相邻元素之间用逗号“,”分隔,如下所示:

    (element1, element2, ... , elementn)

    其中 element1~elementn 表示元组中的各个元素,个数没有限制,且只要是 Python 支持的数据类型就可以。

    从存储内容上看,元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同,例如:

    ("c.biancheng.net",1,[2,'a'],("abc",3.0))

    在这个元组中,有多种类型的数据,包括整形、字符串、列表、元组。

    另外,我们都知道,列表的数据类型是 list,那么元组的数据类型是什么呢?通过 type() 函数,就可以查看到元组的数据类型,例如:

    >>> type(("c.biancheng.net",1,[2,'a'],("abc",3.0)))
    <class 'tuple'>

    Python创建元组

    Python 提供了多种创建元组的方法,下面一一进行介绍。

    = 运算符直接创建元组

    和其他类型的 Python 变量一样,在创建元组时,可以使用赋值运算符“=”直接将一个元组赋值给变量,其语法格式如下

    tuplename = (element1,element2,...,elementn)

    其中,tuplename 表示创建的元组名,可以使用任何符合 Python 命名规则,且不和 Python 内置函数重名的标识符作为元组名。

    再次强调,创建元组的语法和创建列表的语法非常相似,唯一的不同在于,创建列表使用的是 [],而创建元组使用的是 ()。

    例如,下面定义的元组都是合法的:

    num = (7,14,21,28,35)
    a_tuple = ("C语言中文网","http://c.biancheng.net")
    python = ("Python",19,[1,2],('c',2.0))

    在 Python 中,元组通常都是使用一对小括号将所有元素括起来的,但小括号不是必须的,只要将各元素用逗号隔开,Python 就会将其视为元组,举个例子:

    a_tuple = "C语言中文网","http://c.biancheng.net"
    print(a_tuple)

    运行结果为:

    ('C语言中文网', 'http://c.biancheng.net')

    需要额外注意的一点是,当创建的元组中只有一个元素时,此元组后面必须要加一个逗号“,”,否则 Python 解释器会将其误认为字符串。例如:

    #创建元组 a_typle
    a_tuple =("C语言中文网",)
    print(type(a_tuple))
    print(a_tuple)
    #创建字符串 a
    a = ("C语言中文网")
    print(type(a))
    print(a)

    运行结果为:

    <class 'tuple'>
    ('C语言中文网',)
    <class 'str'>
    C语言中文网

    显然,前者 a_tuple 才是元组类型,而变量 a 只是一个字符串。

    使用tuple()函数创建元组

    除了第一种最常见的创建方式外,Python还提供了 tuple() 函数来创建元组,它可以直接将列表、区间(range)等对象转换成元组。

    tuple 函数的语法格式如下:

    tuple(data)

    其中,data 表示可以转化为元组的数据,其类型可以是字符串、元组、range 对象等。

    例如如下代码:

    # 将列表转换成元组
    a_list = ['crazyit', 20, -1.2]
    a_tuple = tuple(a_list)
    print(a_tuple)
    # 使用range()函数创建区间(range)对象
    a_range = range(1, 5)
    print(a_range)
    # 将区间转换成元组
    b_tuple = tuple(a_range)
    print(b_tuple)
    # 创建区间时还指定步长
    c_tuple = tuple(range(4, 20, 3))
    print(c_tuple)

    运行结果为:

    ('crazyit', 20, -1.2)
    range(1, 5)
    (1, 2, 3, 4)
    (4, 7, 10, 13, 16, 19)

    Python访问元组元素

    和列表完全一样,如果想访问元组中的指定元素,可以使用元组中各元素的索引值获取,例如,定义一个包含 3 个元素的元组,若想访问第 2 个元素,可以使用如下的代码:

    a_tuple = ('crazyit', 20, -1.2)
    print(a_tuple[1])

    运行结果为:

    20

    在此基础上,元组也支持采用切片方式获取指定范围内的元素,例如,访问 a_tuple 元组中前 2 个元组,可以执行如下代码:

    a_tuple = ('crazyit', 20, -1.2)
    #采用切片方式
    print(a_tuple[:2])

    运行结果为:

    ('crazyit', 20)

    有关切片的语法格式以及用法,已在《Python序列》一节中做了详细介绍

    Python修改元组元素

    前面已经讲过,元组是不可变序列,元组中的元素不可以单独进行修改。但是,元组也不是完全不能修改。

    比如,我们可以对元组进行重新赋值:

    a_tuple = ('crazyit', 20, -1.2)
    print(a_tuple)
    #对元组进行重新赋值
    a_tuple = ('c.biancheng.net',"C语言中文网")
    print(a_tuple)

    运行结果为:

    ('crazyit', 20, -1.2)
    ('c.biancheng.net', 'C语言中文网')

    另外,还可以通过连接多个元组的方式向元组中添加新元素。例如:

    a_tuple = ('crazyit', 20, -1.2)
    print(a_tuple)
    #连接多个元组
    a_tuple = a_tuple + ('c.biancheng.net',)
    print(a_tuple)

    运行结果为:

    ('crazyit', 20, -1.2)
    ('crazyit', 20, -1.2, 'c.biancheng.net')

    需要注意的是,在使用此方式时,元组连接的内容必须都是元组,不能将元组和字符串或列表进行连接,否则或抛出 TypeError 错误。例如:

    a_tuple = ('crazyit', 20, -1.2)
    #元组连接字符串
    a_tuple = a_tuple + 'c.biancheng.net'
    print(a_tuple)

    运行结果为:

    Traceback (most recent call last):
      File "C:\Users\mengma\Desktop\1.py", line 4, in <module>
        a_tuple = a_tuple + 'c.biancheng.net'
    TypeError: can only concatenate tuple (not "str") to tuple

    Python删除元组

    当已经创建的元组确定不再使用时,可以使用 del 语句将其删除,例如:

    a_tuple = ('crazyit', 20, -1.2)
    print(a_tuple)
    #删除a_tuple元组
    del(a_tuple)
    print(a_tuple)

    运行结果为:

    ('crazyit', 20, -1.2)
    Traceback (most recent call last):
      File "C:\Users\mengma\Desktop\1.py", line 4, in <module>
        print(a_tuple)
    NameError: name 'a_tuple' is not defined

    前面已经介绍过,在实际开发中,del() 语句并不常用,因为 Python 自带的垃圾回收机制会自动销毁不用的元组。

    展开全文
  • Scala之Tuple元组

    2019-12-11 20:24:10
    Tuple元组 元组Tuple是一组不同类型值的集合,被圆括号包含。 如:val tuple = ("scala",10) 在scala中,元组有以下几个特点: 1.元组是可以包含不同类型的元素的 2.元组的索引是从1开始的,而像Array数组的索引是...

    Tuple元组

    元组Tuple是一组不同类型值的集合,被圆括号包含。
    如:val tuple = ("scala",10)
    在scala中,元组有以下几个特点:
    1.元组是可以包含不同类型的元素的
    2.元组的索引是从1开始的,而像Array数组的索引是从0开始的
    对于元组的元素可以使用_1,_2…来访问,如

    object Tuple {
      def main(args: Array[String]): Unit = {
        val tuple = (100,"spark","scala")
        println(tuple._1)  // 100
        println(tuple._2)  // spark
        println(tuple._3)  // scala
      }
    }
    

    运行结果:
    在这里插入图片描述
    还可以使用模式匹配获得元组中的元素:

    object Tuple {
    object Tuple {
      def main(args: Array[String]): Unit = {
        val tuple = (100,"spark","scala")
        println(tuple._1)  // 100
        println(tuple._2)  // spark
        println(tuple._3)  // scala
        println("==============")
        val (a,b,c) = tuple
        println(a)
        println(b)      //1
        println(c)
        println("==============")
        val (a1,b1,_) = tuple
        println(a1)     //2
        println(b1)
       println("===============")
        val a2,b2 = tuple
        println(a2)     //3
        println(b2)
      }
    }
    

    注释1:我们定义的(1,2,3)变量可以根据模式匹配(100,“spark”,“scala”)与其中的元素一一对应
    注释2:可以对单独的几个元素进行匹配,不需要匹配的元素用_占位符替换即可
    注释3:如果去掉括号,则是变为单独的几个变量进行整个元组的匹配
    在这里插入图片描述

    展开全文
  • scala中Tuple元组大全

    2020-03-03 19:21:37
    元组(Tuple) 映射是K/V对偶的集合,对偶是元组的最简单形式,元组可以装着多个不同类型的值,是不同类型的值的聚集。 三.代码举例 映射是K/V对偶的集合,对偶是元组的最简单形式,元组可以装着多个不同类型...

    美图欣赏:
    在这里插入图片描述
    一.背景

    元组在操作Spark中还是非常多的

    二.元组(Tuple)

    映射是K/V对偶的集合,对偶是元组的最简单形式,元组可以装着多个不同类型的值,是不同类型的值的聚集。

    三.代码举例

    1.第一种方法: 创建一个Tuple元组

    scala> val tuple = (1, "Jackson" , 2.5 , 100L , 20F)
    tuple: (Int, String, Double, Long, Float) = (1,Jackson,2.5,100,20.0)
    
    

    2.Tuple元组进行取值

    scala> tuple._1
    res39: Int = 1
    
    scala> tuple._2
    res40: String = Jackson
    
    

    3.第二种方法: 创建一个Tuple元组

    使用new Tuple ,后面要写上添加几个元素(切记)

    scala> val tuple1 = new Tuple3(1,2,3)
    tuple1: (Int, Int, Int) = (1,2,3)
    
    scala> val tuple1 = new Tuple2(4,5)
    tuple1: (Int, Int) = (4,5)
    
    scala> val tuple1 = new Tuple1(1,2,3)
    tuple1: ((Int, Int, Int),) = ((1,2,3),)
    
    

    4.目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合,或者扩展元组。

    //源码
    @deprecatedInheritance("Tuples will be made final in a future version.", "2.11.0")
    case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22)
      extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]
    {
      override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + "," + _11 +
        "," + _12 + "," + _13 + "," + _14 + "," + _15 + "," + _16 + "," + _17 + "," + _18 + "," + _19 + "," + _20 + "," + _21 + "," + _22 + ")"
      
    }
    

    5.另一种定义Tuple方法

    scala> val tup,(x,y,z)=(1,2,3)
    tup: (Int, Int, Int) = (1,2,3)
    x: Int = 1
    y: Int = 2
    z: Int = 3
    
    scala> x
    res41: Int = 1
    
    scala> y
    res42: Int = 2
    
    scala> z
    res43: Int = 3
    
    
    

    6.进行打印出来

    scala> tup.toString
    res44: String = (1,2,3)
    
    

    7.swap进行转换(只能俩元素)

    scala> val tup1 = (1,2)
    tup1: (Int, Int) = (1,2)
    
    scala> tup1.swap
    res45: (Int, Int) = (2,1)
    
    

    8.元组遍历

    方式1for (elem <- tuple1.productIterator) {
      print(elem)
    }
    println()
    
    方式2:
    tuple1.productIterator.foreach(i => println(i))
    tuple1.productIterator.foreach(print(_))
    
                     ————保持饥饿,保持学习
                           Jackson_MVP
    
    展开全文
  • Python3基础 Tuple元组

    2019-10-23 11:14:29
    元组的元素不可修改 元组使用圆括号() 使用() 创建一个元组,每个元组中的值由逗号,分隔: name = ('zhangsan', 'lisi', 'wangwu') print(name) 创建一个空元组 name = () print(name) 创建一个只有一个元素的...
  • C++-tuple元组

    2020-02-05 01:35:08
    文章目录1tuple元组2 功能介绍3 实例 1tuple元组 是什么? tuple是一个固定大小的不同类型值的集合。是一个可以容纳不同类型元素的容器 。 我们也可以把他当做一个通用的结构体来用,不需要创建结构体又获取...
  • c++11 tuple元组

    2021-04-22 16:13:06
    tuple元组是一个固定大小的不同类型值的集合,是泛化的std::pair。可以把它当成一个通用的结构体来用,不需要创建结构体又获取结构体的特征,在某些情况下可以取代结构体。 1、构造一个tuple: std::tuple<const ...
  • 元组的使用,元组的操作
  • Tuple元组

    2016-10-14 14:17:43
    元组是C# 4.0后出的新特性,数组合并了相同类型的对象,元组合并了不同类型的对象 Tuple的好处 最常用的一种方式就是替代了out,使用out多返回一个值还是挺简单,但是假设一个方法要返回N个值,那么out写起来就...
  • tuple 元组 移除和增加元素的方法

    千次阅读 2019-09-14 20:33:59
    python中 tuple 没有 像 List 那样的 append, remove 方法, 我们可以通过以下, 实现 增加 require_add_element = 5 tup = (1,2,3,4) tup = tup + (require_add_element,) print(tup) 移除 require_remove_element =...
  • } //-------------------- //Tuple元组: C# 4.0的新特性 //是一种数据结构,引用类型,具有特定数量和元素序列 //最多有八个元素,要想更多只能通过最后一个元素进行嵌套扩展,(使用值元组的嵌套和Rest属性实现) ...
  • scala Tuple元组

    2020-07-19 16:43:59
    目录Tuple的创建 访问 遍历 元组也是可以理解为一个容器,可以存放各种相同或不同类型的数据。 元组中最大只能有 22 个元素 Tuple的类型有22种 例如Tuple中有4个元素,叫Tuple4 依次类推即可 Tuple的创建 访问 遍历...
  • tuple 元祖类型 是另一种有序的列表,中文翻译为“ 元组 ”。tuple一旦创建完毕,就不能修改了。
  • tuple元组详解概述创建元组(2种方式)使用 ( ) 直接创建使用tuple()函数创建元组访问元组元素修改元组删除元组 概述 元组(tuple)是 Python 中另一个重要的序列结构,和列表类似,元组也是由一系列按特定顺序排序...
  • Python中的tuple元组和namedtuple命名元组 元组的定义和初始化 定义:由一个有序的元素组成的集合。元组是不可变对象 tuple()->empty tuple 返回一个空元组 ()也可以定义一个空元组。 (1,)表示是由一个元素1...
  • Python中的tuple元组和dict字典的用法

    千次阅读 2019-03-19 17:02:49
    1.tuple元组 (1)元组的基本知识 a)概念:是一种有序的集合 b)元组和列表的区别: 格式: 元组:(),列表:[ ]; 列表中的元素可以进行增加和删除操作,但是,元组中的元素不能进行修改 c)元组和列表的...
  • tuple 元组的简单介绍

    2020-07-30 10:17:37
    tuple元组 tuple是一个固定大小的不同类型值的集合,是泛华的 std::pair 。 在使用时可以将其当做结构体使用,可以不用创建结构体而获得结构体的特征,在某些情况下可以取代结构体使用。 tuole 元组的构造方法: /...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,505
精华内容 40,202
关键字:

tuple元组