精华内容
下载资源
问答
  • 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 元组

    2016-08-01 16:33:00
    tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别.是对pair的泛化。 首先来介绍元组的创建和元组元素的访问。通过make_tuple()创建元组,通过get #...

    tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别.是对pair的泛化。

    首先来介绍元组的创建和元组元素的访问。通过make_tuple()创建元组,通过get<>()来访问元组的元素。通过下面这段程序来认识这两个函数的用法:

    #include <iostream>

    #include <tuple>

    #include <functional>

     

    int main()

    {

        auto t1 = std::make_tuple(10, "Test", 3.14);

        std::cout << "The value of t1 is "

                  << "(" << std::get<0>(t1) << ", " << std::get<1>(t1)

                  << ", " << std::get<2>(t1) << ")\n";

     

        int n = 1;

        auto t2 = std::make_tuple(std::ref(n), n);//ref表示引用

        n = 7;

        std::cout << "The value of t2 is "

                  << "(" << std::get<0>(t2) << ", " << std::get<1>(t2) << ")\n";

    }

    运行结果为:

    The value of t1 is (10, Test, 3.14)

    The value of t2 is (7, 1)

     

    接下来介绍tie()函数。 tie()函数可以将变量连接到一个给定的tuple上,生成一个元素类型全是引用的tuple,相当于make_tuple(ref(a),ref(b),…)。可以通过tie()函数的使用方便的对tuple进行“解包”操作。看下面的代码:

    #include <iostream>

    #include <tuple>

     

    int main ()

    {

      int myint;

      char mychar;

      float myfloat;

     

      std::tuple<int,float,char> mytuple;

     

      mytuple = std::make_tuple (10, 2.6, 'a');          // packing values into tuple

     

      //std::tie (myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables  【1】

      std::tie (myint,myfloat, mychar) = mytuple;

     

      std::cout << "myint contains: " << myint << std::endl;

      std::cout << "mychar contains: " << mychar << std::endl;

      std::cout << "myfloat contains: "<< myfloat <<std::endl;

     

      std::get<0>(mytuple) = 100;//修改tuple的值

     

      std::cout <<"After assignment myint contains: "<< std::get<0>(mytuple) << std::endl;

     

      return 0;

    }

    运行结果:

    myint contains: 10

    mychar contains: a

    myfloat contains: 2.6

    After assignment myint contains: 100

    注:正如【1】处我们可以使用std::ignore,从而不用关联tuple中的第二个元素.

     

    最后介绍一个tuple_cat()函数,通过该函数可以将多个tuple连接起来形成一个tuple(注:在VC11中只能连接两个tuple并不是真正的多个tuple)。

    #include <iostream>

    #include <utility>

    #include <string>

    #include <tuple>

     

    int main ()

    {

     

      std::tuple<float,std::string> mytuple (3.14,"pi");

      std::pair<int,char> mypair (10,'a');

     

      auto myauto = std::tuple_cat ( mytuple, mypair );

     

      std::cout << "myauto contains: " << std::endl;

      std::cout << std::get<0>(myauto) << std::endl;

      std::cout << std::get<1>(myauto) << std::endl;

      std::cout << std::get<2>(myauto) << std::endl;

      std::cout << std::get<3>(myauto) << std::endl;

     

      return 0;

    }

    运行结果:

     

    myauto contains:

    3.14

    pi

    10

    a

    展开全文
  • Tuple元组

    2019-09-23 14:44:40
    元组和列表的定义上看,这两种结构比较类似,元组为不可变序列,列表为可变序列。 元组中的元素不可以单独修改,只能整体修改元组。而列表可以任意修改。 tuplename=(element1,element2) 元组使用一对小括号...

    从元组和列表的定义上看,这两种结构比较类似,元组为不可变序列,列表为可变序列。

    元组中的元素不可以单独修改,只能整体修改元组。而列表可以任意修改。

     

    tuplename=(element1,element2)

     

    元组使用一对小括号将所有元素括起来,但小括号不是必须的。有逗号就可以。

    uk="高山流水”,“下里巴人”  #元组

    uk="高山流水“,  #元组

    uk="高山流水"  #字符串

     

     

    1.空元组

    emptytuple=()

     

    2.创建数值元组

    tuple(range(10,20,2))

     

    3.元组只能连接元组或整体改变值

    uk2=uk+('麝香猫‘,)

     

    元组与列表的区别:

    1.列表不能作为字典的键,元组可以。

    2.元组比列表的访问和处理速度快。所以只对其中的元素进行访问,而不是修改时,建议使用元组

    3.列表可以使用切片访问和修改列表中的元素

     

    转载于:https://www.cnblogs.com/lelin/p/11568433.html

    展开全文
  • Tuple 元组

    2018-12-24 14:58:26
    HALCON学习之TUPLE * define a tuple for int, double, string... not for object d:=[] * assignment d[0] := 'a string' * get tuple length, method 1: leng:=|d| * get tuple length, method 2: tuple_length...

    HALCON单相机标定

     

     

     

    HALCON学习之TUPLE

    * define a tuple for int, double, string... not for object
    d:=[]
    * assignment
    d[0] := 'a string'
    * get tuple length, method 1:
    leng:=|d|
    * get tuple length, method 2:
    tuple_length(d,leng)
    * get length of object tuple
    count_obj (ContoursSplit, Number)
    

    对tuple数组执行相关的转化操作

    .I()    integer

    .S()   string?

    .D()   double

    ......

     

    Python Tuple元组的操作说明

    一、tuple也是一个class,是不可变的list类型,不可以增删改。

    #创建:
    
    tup1 = ('physics', 'chemistry', 1997, 2000);
    tup2 = (1, 2, 3, 4, 5 );
    tup3 = "a", "b", "c", "d";
    

    访问:(与list一样)tup1[1:5];

    修改:不可以修改,只能增加新的部分;

    tup3 = tup1 + tup2;
    print tup3;
    


    二、任意无符号的对象,以逗号隔开,默认为元组,如下实例:

    a=1,2,3,'e'

    a=(1,2,3,'e')

    三、Python元组包含了以下内置函数(与list差不多的函数)
    1、cmp(tuple1, tuple2):比较两个元组元素。
    2、len(tuple):计算元组元素个数。
    3、max(tuple):返回元组中元素最大值。
    4、min(tuple):返回元组中元素最小值。
    5、tuple(seq):将列表转换为元组。

    四、tuple的方法:

    1、count():查找元素在tuple中出现的次数。

    2.index():查找元素的第一个索引值。

    五、Tuple 是不可变 list。 一旦创建了一个 tuple 就不能以任何方式改变它。


    ①、Tuple 与 list 的相同之处

    定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号。
    Tuple 的元素与 list 一样按定义的次序进行排序。 Tuples 的索引与 list 一样从 0 开始, 所以一个非空 tuple 的第一个元素总是 t[0]。
    负数索引与 list 一样从 tuple 的尾部开始计数。
    与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时, 会得到一个新的 list ;当分割一个 tuple 时, 会得到一个新的 tuple。

    ②、Tuple 不存在的方法

    您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
    您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
    然而, 您可以使用 in 来查看一个元素是否存在于 tuple 中。

    ③、用 Tuple 的好处

    Tuple 比 list 操作速度快。如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list。
    如果对不需要修改的数据进行 “写保护”,可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句,说明这一数据是常量。如果必须要改变这些值,则需要执行 tuple 到 list 的转换。

    ④、Tuple 与 list 的转换

    Tuple 可以转换成 list,反之亦然。内置的 tuple 函数接收一个 list,并返回一个有着相同元素的 tuple。而 list 函数接收一个 tuple 返回一个 list。从效果上看,tuple 冻结一个 list,而 list 解冻一个 tuple。

    Tuple的特性在于,一旦设定,就不能使用索引去修改。

     

     

     

    Python中的Tuple

    Tuple 元组

     

     


    Reference

    python中元组(tuple)用法总结

    2 HALCON学习之TUPLE

     

     

     

     

    展开全文
  • C++ tuple元组

    2020-09-15 00:18:00
    tuple元组 tuple是一个元组容器,可以用于函数返回多个值, 一个tuple元组可以有任意数量的成员 tuple的两种初始化方式: tuple<int, int> t1(1, 2); tuple<int, int> t2{1, 2}; make_tuple用于生成...
  • 本文实例讲述了Python数据类型之Tuple元组。分享给大家供大家参考,具体如下: tuple元组 1.概述 本质上是一种有序的集合,和列表非常的相似,列表使用[]表示,元组使用()表示. 特点:一旦初始化,就不能发生改变 2....
  • 主要介绍了Python中的tuple元组详细介绍,本文讲解了Tuple 与 list 的相同之处、Tuple 不存在的方法、用 Tuple 的好处、Tuple 与 list 的转换等内容,需要的朋友可以参考下
  • Python基础:tuple元组

    2018-02-13 11:38:07
    前面看过了list列表的特性以及通用操作和常用操作,今天我们来看一下不可变序列中的tuple元组,与list列表最大的不同在于,tuple元组不支持原位改变 接下来我们通过一段代码来测试一下tuple元组的特性以及通用操作...
  • C++-tuple元组

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

    2021-03-23 15:55:52
    参考:C++ tuple元组的基本用法(总结) 参考:
  • Tuple元组基本操作

    2018-05-17 12:58:00
      本实验任务主要完成了Python的环境搭建,并对Tuple元组进行一些基本操作,通过完成本实验任务,要求学生熟练掌握Tuple元组的函数及内置方法,并对Tuple的基本操作进行整理并填写工作任务报告。 二、任务目标 1...
  • 主要介绍了C++ tuple元组的基本用法(总结),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Scala之Tuple元组

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

    2019-07-21 09:08:54
    Tuple 元组 与列表一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。 元组的值是通过将单个的值包含在圆括号中构成的。例如: ...
  • C++11 tuple元组

    2020-04-11 14:22:04
    C++11 tuple 元组 tuple容器(元组), 是表示元组容器, 是不包含任何结构的,快速而低质(粗制滥造, quick and dirty)的, 可以用于函数返回多个返回值; tuple容器, 可以使用直接初始化, 和"make_tuple()"初始化, 访问...
  • Python tuple元组详解

    2020-10-14 23:11:20
    Python tuple元组详解 Python创建元组 Python中提供了两种方法创建元组; 1、使用()直接创建元组 通过( )创建元组后,一般使用=将它赋值给某个变量,具体格式为: tuplename = (element1, element2, …, ...
  • Python 元组tuple )它和list列表类似,唯一的差别是元组不能修改。tuple 元组是有序的,一旦定义了元组我们就不能修改它。一、定义元组tuple 元组定义使用小括号 ( ), list 列表使用中括号 [ ] .l 注意:元组中...
  • python tuple元组操作

    2019-09-28 06:15:18
    python tuple元组常用操作 元组也是一种序列,唯一不同的是元组中的数据不能修改,且元组是通过圆括号括起来 tuple()函数,将数据转换为元组 list_a=["a","b","c","abc"] str_a="python" print tuple(list_...
  • python中的Tuple元组

    2021-03-31 14:23:02
    Tuple元组 tuple和list有一些类似 tuple () , list [] tuple 1、元组是python中常用的一种数据结构,元组的元素可以存储不同的数据类型的数据,如:字符串、数字、元组等。 2、元组相当于不定长数组,创建可以不指定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,912
精华内容 5,964
关键字:

tuple元组