精华内容
下载资源
问答
  • 元组类型
    2022-07-02 18:07:15

    简介

    元组就是将一组松散的对象简单地组合在一起。

    元组比数组灵活性略强,数组中元素类型是统一的,而元组使用的是泛型参数,每个元素类型相互独立。

    元组不同于类和结构,类和结构是高度聚合的数据类型,其中要实现各种复杂的功能;元组还是一系列单一对象的简单组合,不存在复杂操作。

    元组中将所有元素分配给Item属性,其中表示序号,例如Item1、Item2等,取决于元素个数,可容纳1~8个。

    用法

    元组功能在 C# 7.0 及更高版本中可用,它提供了简洁的语法,用于将多个数据元素分组成一个轻型数据结构。下面的示例演示了如何声明元组变量、对它进行初始化并访问其数据成员:

    (double, int) t1 = (4.5, 3);Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");// Output:// Tuple with elements 4.5 and 3.
    (double Sum, int Count) t2 = (4.5, 3);Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");// Output:// Sum of 3 elements is 4.5.

    如前面的示例所示,若要定义元组类型,需要指定其所有数据成员的类型,或者,可以指定字段名称。虽然不能在元组类型中定义方法,但可以使用 .NET 提供的方法,如下面的示例所示:

    (double, int) t = (4.5, 3);Console.WriteLine(t.ToString());Console.WriteLine($"Hash code of {t} is {t.GetHashCode()}.");// Output:// (4.5, 3)// Hash code of (4.5, 3) is 718460086.

    从 C# 7.3 开始,元组类型支持相等运算符== 和 !=。有关详细信息,请参阅元组相等部分。

    元组类型是值类型;元组元素是公共字段。这使得元组为可变的值类型。

    备注

    元组功能需要 System.ValueTuple 类型和相关的泛型类型(例如 System.ValueTuple<T1,T2>),这些类型在 .NET Core 和 .NET Framework 4.7 及更高版本中可用。若要在面向 .NET Framework 4.6.2 或更早版本的项目中使用元组,请将 NuGet 包 System.ValueTuple 添加到项目。

    可以使用任意数量的元素定义元组:

    var t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11, 12, 13, 14, 15, 16, 17, 18,19, 20, 21, 22, 23, 24, 25, 26);Console.WriteLine(t.Item26);  // output: 26
    更多相关内容
  • 主要介绍了Java元组类型javatuples使用实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 元组类型

    千次阅读 2020-08-30 15:26:32
    1.用途:元组就是一个不可变的列表 2.定义方式:在小括号()内用逗号分隔开多个任意类型的值 l=[111,222,333] print(type(l)) #list t=(111,222,333) print(type(t)) #tuple 类型转换 tuple,任意能够被for循环遍历...

    1.用途

    元组就是一个不可变的列表

    2.定义方式

    在小括号()内用逗号分隔开多个任意类型的值

    l=[111,222,333]
    print(type(l))  #list
    t=(111,222,333)
    print(type(t))  #tuple
    

    类型转换
    tuple,任意能够被for循环遍历的类型
    list,任意能够被for循环遍历的类型
    强调:如果是存一个值的元组,需要加上逗号

    t = (11,)
    print(type(t))
    <class 'tuple'>
    t=(111,222,[333,444])
    print(id(t[0]),id(t[1]),id(t[2]))
    t[2][1]=555
    print(t)
    print(id(t[0]),id(t[1]),id(t[2]))
    

    元组为不可变类型,是整体的不可变,如果元组内的值是可变类型,
    且改变值不影响单独值的内存空间,即也不影响整个元组的内存空间,
    那么可发生改变

    3.常用操作+内置的方式

    1.按索引取值(正向取,反向取)
    2.切片(顾头不顾尾,步长)

    t=(111,222,333)
    print(t[0:2]) #相当于重新复制一份
    print(t)   #t定义的元组量还在
    

    3.长度

    t=(111,222,333)
    print(len(t))
    

    4.成员运算in和not in
    t=(111,222,333)
    print(111 in t)

    5.循环

    t=(111,222,333)
    for i in t:
        print(i)
    #需要掌握的内置方法
    t=(151,111,333,444,555,111)
    print(t.index(111)) #找到最先的一个直接报索引,且终止查找
    print(t.count(111)) #查找有几个
    

    该类型总结
    多个值
    有序
    不可变

    展开全文
  • C#——元组类型

    千次阅读 2021-01-12 18:04:13
    C#——元组类型 元组功能在 C# 7.0 及更高版本中可用,它提供了简洁的语法,用于将多个数据元素分组成一个轻型数据结构。 下面的示例演示了如何声明元组变量、对它进行初始化并访问其数据成员:、 (double, int) t1 ...

    C#——元组类型

    元组功能在 C# 7.0 及更高版本中可用,它提供了简洁的语法,用于将多个数据元素分组成一个轻型数据结构。 下面的示例演示了如何声明元组变量、对它进行初始化并访问其数据成员:、

    (double, int) t1 = (4.5, 3);
    Console.WriteLine($"Tuple with elements {t1.Item1} and {t1.Item2}.");
    // Output:
    // Tuple with elements 4.5 and 3.
    
    (double Sum, int Count) t2 = (4.5, 3);
    Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
    // Output:
    // Sum of 3 elements is 4.5.
    

    如前面的示例所示,若要定义元组类型,需要指定其所有数据成员的类型,或者,可以指定字段名称。 虽然不能在元组类型中定义方法,但可以使用 .NET 提供的方法,如下面的示例所示:、

    (double, int) t = (4.5, 3);
    Console.WriteLine(t.ToString());
    Console.WriteLine($"Hash code of {t} is {t.GetHashCode()}.");
    // Output:
    // (4.5, 3)
    // Hash code of (4.5, 3) is 718460086.
    

    从 C# 7.3 开始,元组类型支持相等运算符 == 和 !=。
    元组类型是值类型;元组元素是公共字段。 这使得元组为可变的值类型。

    元组功能需要 System.ValueTuple 类型和相关的泛型类型(例如 System.ValueTuple<T1,T2>),这些类型在 .NET Core 和 .NET Framework 4.7 及更高版本中可用。 若要在面向 .NET Framework 4.6.2 或更早版本的项目中使用元组,请将 NuGet 包 System.ValueTuple 添加到项目。

    可以使用任意数量的元素定义元组:

    var t = 
    (1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    11, 12, 13, 14, 15, 16, 17, 18,
    19, 20, 21, 22, 23, 24, 25, 26);
    Console.WriteLine(t.Item26);  // output: 26
    

    元组的用例

    元组最常见的用例之一是作为方法返回类型。 也就是说,你可以将方法结果分组为元组返回类型,而不是定义 out 方法参数,如以下示例所示:

    var xs = new[] { 4, 7, 9 };
    var limits = FindMinMax(xs);
    Console.WriteLine($"Limits of [{string.Join(" ", xs)}] are {limits.min} and {limits.max}");
    // Output:
    // Limits of [4 7 9] are 4 and 9
    
    var ys = new[] { -9, 0, 67, 100 };
    var (minimum, maximum) = FindMinMax(ys);
    Console.WriteLine($"Limits of [{string.Join(" ", ys)}] are {minimum} and {maximum}");
    // Output:
    // Limits of [-9 0 67 100] are -9 and 100
    
    (int min, int max) FindMinMax(int[] input)
    {
        if (input is null || input.Length == 0)
        {
            throw new ArgumentException("Cannot find minimum and maximum of a null or empty array.");
        }
    
        var min = int.MaxValue;
        var max = int.MinValue;
        foreach (var i in input)
        {
            if (i < min)
            {
                min = i;
            }
            if (i > max)
            {
                max = i;
            }
        }
        return (min, max);
    }
    

    如前面的示例所示,可以直接使用返回的元组实例,或者可以在单独的变量中析构它。

    还可以使用元组类型,而不是匿名类型;例如,在 LINQ 查询中。

    通常,你会使用元组对相关的数据元素进行松散分组。 这通常在专用和内部实用工具方法中有用。 对于公共 API 用例,请考虑定义类或结构类型。

    元组字段名称

    可以在元组初始化表达式中或元组类型的定义中显式指定元组字段的名称,如下面的示例所示:

    var t = (Sum: 4.5, Count: 3);
    Console.WriteLine($"Sum of {t.Count} elements is {t.Sum}.");
    
    (double Sum, int Count) d = (4.5, 3);
    Console.WriteLine($"Sum of {d.Count} elements is {d.Sum}.");
    

    从 C# 7.1 开始,如果未指定字段名称,则可以根据元组初始化表达式中相应变量的名称推断出此名称,如下面的示例所示:

    var sum = 4.5;
    var count = 3;
    var t = (sum, count);
    Console.WriteLine($"Sum of {t.count} elements is {t.sum}.");
    

    这称为元组投影初始值设定项。 在以下情况下,变量名称不会被投影到元组字段名称中:

    • 候选名称是元组类型的成员名称,例如 Item3、ToString 或 Rest。
    • 候选名称是另一元组的显式或隐式字段名称的重复项。

    在这些情况下,你可以显式指定字段的名称,或按字段的默认名称访问字段。

    元组字段的默认名称为 Item1、Item2、Item3 等。 始终可以使用字段的默认名称,即使字段名称是显式指定的或推断出的,如下面的示例所示:

    var a = 1;
    var t = (a, b: 2, 3);
    Console.WriteLine($"The 1st element is {t.Item1} (same as {t.a}).");
    Console.WriteLine($"The 2nd element is {t.Item2} (same as {t.b}).");
    Console.WriteLine($"The 3rd element is {t.Item3}.");
    // Output:
    // The 1st element is 1 (same as 1).
    // The 2nd element is 2 (same as 2).
    // The 3rd element is 3.
    

    元组赋值和元组相等比较不会考虑字段名称。

    在编译时,编译器会将非默认字段名称替换为相应的默认名称。 因此,显式指定或推断的字段名称在运行时不可用。

    元组赋值和析构

    C# 支持满足以下两个条件的元组类型之间的赋值:

    • 两个元组类型有相同数量的元素
    • 对于每个元组位置,右侧元组元素的类型与左侧相应的元组元素的类型相同或可以隐式转换为左侧相应的元组元素的类型

    元组元素是按照元组元素的顺序赋值的。 元组字段的名称会被忽略且不会被赋值,如下面的示例所示:

    (int, double) t1 = (17, 3.14);
    (double First, double Second) t2 = (0.0, 1.0);
    t2 = t1;
    Console.WriteLine($"{nameof(t2)}: {t2.First} and {t2.Second}");
    // Output:
    // t2: 17 and 3.14
    
    (double A, double B) t3 = (2.0, 3.0);
    t3 = t2;
    Console.WriteLine($"{nameof(t3)}: {t3.A} and {t3.B}");
    // Output:
    // t3: 17 and 3.14
    

    还可以使用赋值运算符 = 在单独的变量中析构元组实例。 为此,可以使用以下方式之一进行操作:

    • 在括号内显式声明每个变量的类型:
    var t = ("post office", 3.6);
    (string destination, double distance) = t;
    Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    // Output:
    // Distance to post office is 3.6 kilometers.
    
    • 在括号外使用 var 关键字来声明隐式类型化变量,并让编译器推断其类型:
    var t = ("post office", 3.6);
    var (destination, distance) = t;
    Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    // Output:
    // Distance to post office is 3.6 kilometers.
    
    • 使用现有变量:
    var destination = string.Empty;
    var distance = 0.0;
    
    var t = ("post office", 3.6);
    (destination, distance) = t;
    Console.WriteLine($"Distance to {destination} is {distance} kilometers.");
    // Output:
    // Distance to post office is 3.6 kilometers.
    

    元组相等

    从 C# 7.3 开始,元组类型支持 == 和 != 运算符。 这些运算符按照元组元素的顺序将左侧操作数的成员与相应的右侧操作数的成员进行比较。

    (int a, byte b) left = (5, 10);
    (long a, int b) right = (5, 10);
    Console.WriteLine(left == right);  // output: True
    Console.WriteLine(left != right);  // output: False
    
    var t1 = (A: 5, B: 10);
    var t2 = (B: 5, A: 10);
    Console.WriteLine(t1 == t2);  // output: True
    Console.WriteLine(t1 != t2);  // output: False
    

    如前面的示例所示,== 和 != 操作不会考虑元组字段名称

    同时满足以下两个条件时,两个元组可比较:

    • 两个元组具有相同数量的元素。 例如,如果 t1 和 t2 具有不同数目的元素,t1 != t2 则不会进行编译。
    • 对于每个元组位置,可以使用 == 和 != 运算符对左右侧元组操作数中的相应元素进行比较。 例如,(1, (2, 3)) == ((1, 2), 3) 不会进行编译,因为 1 不可与 (1, 2) 比较。

    == 和 != 运算符将以短路方式对元组进行比较。 也就是说,一旦遇见一对不相等的元素或达到元组的末尾,操作将立即停止。 但是,在进行任何比较之前,将对所有元组元素进行计算,如以下示例所示:

    Console.WriteLine((Display(1), Display(2)) == (Display(3), Display(4)));
    
    int Display(int s)
    {
        Console.WriteLine(s);
        return s;
    }
    // Output:
    // 1
    // 2
    // 3
    // 4
    // False
    

    元组作为 out 参数

    通常,你会将具有 out 参数的方法重构为返回元组的方法。 但是,在某些情况下,out 参数可以是元组类型。 下面的示例演示了如何将元组作为 out 参数使用:

    var limitsLookup = new Dictionary<int, (int Min, int Max)>()
    {
        [2] = (4, 10),
        [4] = (10, 20),
        [6] = (0, 23)
    };
    
    if (limitsLookup.TryGetValue(4, out (int Min, int Max) limits))
    {
        Console.WriteLine($"Found limits: min is {limits.Min}, max is {limits.Max}");
    }
    // Output:
    // Found limits: min is 10, max is 20
    

    元组与 System.Tuple

    System.ValueTuple 类型支持的 C# 元组不同于 System.Tuple 类型表示的元组。 主要区别如下:

    • ValueTuple 类型是值类型。 Tuple 类型是引用类型。
    • ValueTuple 类型是可变的。 Tuple 类型是不可变的。
    • ValueTuple 类型的数据成员是字段。 Tuple 类型的数据成员是属性。
    展开全文
  • 05-元组类型

    2022-08-22 00:06:10
    / 类型必须匹配且个数必须为 2 x = [ 'hello' , 10 ];/ / Error。

    元组类型是ts新增的类型之一,元组最重要的特性是可以限制数组元素的个数和类型,它特别适合用来实现多值返回。可以说元组就是固定长度的数组,下面开始介绍元组的语法

    元组用于保存定长定数据类型的数据
    let x: [string, number]; // 类型必须匹配且个数必须为2
    x = ['hello', 10]; // OK 
    x = ['hello', 10,10]; // Error 
    x = [10, 'hello']; // Error
    
    元组类型的解构赋值
    let employee: [number, string] = [1, "Semlinker"];
    let [id, username] = employee;
    console.log(`id: ${id}`);
    console.log(`username: ${username}`);
    

    以上代码成功运行后,控制台会输出以下消息:

    id: 1
    username: Semlinker
    

    这里需要注意的是,在解构赋值时,如果解构数组元素的个数是不能超过元组中元素的个数,否则也会出现错误,比如:

    let employee: [number, string] = [1, "Semlinker"];\
    let [id, username, age] = employee;
    

    在以上代码中,我们新增了一个 age 变量,但此时 TypeScript 编译器会提示以下错误信息:

    Tuple type '[number, string]' of length '2' has no element at index '2'.
    
    元组类型的可选元素

    和函数类型一样,元组类型的类型也是可以选择的,用法是在类型定义之后用?

    let a : [string,number?];
    a=['12']    //通过
    a=['asd',1]     //通过
    a=[1,1]     //不通过,第一个元素应该为字符串类型
    
    元组类型的剩余元素

    就像js的数组一样,有场景需要长度不固定的数组,且前几个元素类型已被确定,那么这时候就可以用元组的剩余元素。
    元组类型里最后一个元素可以是剩余元素,形式为 …X,这里 X 是数组类型。剩余元素代表元组类型是开放的,可以有零个或多个额外的元素。 例如,[number, …string[]] 表示带有一个 number 元素和任意数量string 类型元素的元组类型。为了能更好的理解,我们来举个具体的例子:

    type RestTupleType = [number, ...string[]];
    let restTuple: RestTupleType = [666, "Semlinker", "Kakuqo", "Lolo"];
    console.log(restTuple[0]);
    console.log(restTuple[1]);
    
    元组的只读属性

    ts3.4版本的新特性,可以保证元组的元素不被修改,任何企图修改元组中元素的操作都会抛出异常,相当于const关键字

    const point: readonly [number, number] = [10, 20];
    

    不要嘲笑那些比你们拼命努力的人,也不要理会那些嘲笑你拼命努力的人。

    展开全文
  • 元组类型 元组类型类似于数组类型,只是规则略有不同。 数组合并了相同类型的对象,而元组(Tuple)合并了不同类型的对象。 数组类型 首先回顾一下数组类型: typeScript基础(6)_数组类型 其中只要包括数组类型的...
  • JavaScript的元组类型。 安装 package.json / bower.json: dependencies: { "tupl": "andy-hanson/tupl" } 用 import tupl from 'tupl/dist/tupl' export default tupl( // Name is 'Point'. This helps with ...
  • TypeScript 元组类型

    2021-03-09 10:03:16
    TypeScript 语言中,数组中的元素一般只能是由相同数据类型组成(any[] 除外),如果我们想要存储不同类型的元素,则可以使用元组。 TypeScript 中的元组(Tuple)从外形上来看和数组相差不多, 但是元组中允许存储...
  • python中的元组类型

    千次阅读 2020-09-19 21:42:03
    元组: 类似列表,可以被当成容器 特点: 1、定义的符号:() 列表中的符号是[ ] 2、元组中的内容不可修改,相当于元组只能存放东西,但是不能随意修改或者往里面加东西。 但是对列表进行操作可以进行增...
  • Python元组类型数据

    2021-10-09 21:07:06
    一、元组 定义: 元组的定义与列表的定义十分相似。...若元组内只有一个元素,元素的后面必须加上英文的 , 否则 python 会将元组视为唯一元素的元素类型处理。 代码: a = (123,456); print(a); print(type(a));
  • 元组类型是一种不可变的序列,创建之后不能做任何修改 用()创建元组类型,数据项用逗号分隔 数据项可以是任何类型 元组中只有一个元素也要加上逗号,不然解释器会当做整形处理 同样支持切片操作 ...
  • 还可以使用元组类型来定义,元组和列表非常像,都是用于存储数据时使用 列表使用中括号[] 进行定义 元组使用小括号 ()进行定义 元组的值是不能改变的,列表的值是可以改变的 #####注意:在定义元组...
  • 上篇博客已经介绍了序列类型的通用定义,以及一些常用的函数及方法,...本文将具体介绍Python的三种序列类型: 字符串类型,元组类型以及列表类型各自的特点以及特殊用法。 一.字符串类型 二.元组类型 三.列表类型 ...
  • 在藏文信息处理中,实现藏文文字排序的关键在于准确地判断藏文音节,而藏文音节判定的关键是对音节结构元素的识别,本文在...依据组合约束关系,分析了音节七元组的组合类型特征,对藏文正字和音节信息研究具有重要意义
  • 元组类型: 元组是包含多个元素的类型,元素之间用逗号分割。 例如:t1=123,456,“hello” 元组可以是空的,t2=() 元组包含一个元素时:t3=123, 元组外侧可以使用括号,也可以不使用 元组中各元素存在先后关系,...
  • 讨论C#中的元组类型元组类型能做的事二 元组的使用1.定义元组类型及赋值2.定义元组类型的方法3.接收元组方法的返回值4. 弃元 元组功能在 C# 7.0 及更高版本中可用,它提供了简洁的语法,用于将多个数据元素分组成...
  • 详解 Python 中的元组类型

    千次阅读 2018-12-26 12:02:50
    在 Python 中,元组(Tuple)和列表⾮常相似,与列表不同的是,元组⼀旦创⽴,就不可改变,也就是说,元组是不可变的。 与列表一样,元组也是序列,唯一的差别在于元组是不能修改的(你可能注意到了,字符串也不能...
  • 文章目录1.元组2.定义元组3.类型转换4.特殊情况改值4.索引取值5....元组是不可变类型元组元素是列表,列表内的值可以被改)。 当元组内部只有一个元素的时候,逗号不能省略。 一个规则,所有容器.
  • 10-ts元组类型

    2022-08-17 16:31:06
    10-ts元组类型
  • Python数据类型之四四,元组类型1.元组的创建 使用tuple()2.元组的基本操作(1).增删改查(2).其他常用运算符操作和函数3.元组的特殊之处(1). 当元组只包含单一元素时(2).元素不可更改 四,元组类型 python的元组与...
  • 元组合并点网 在C#中合并/合并(实验)
  • python 元组--元组到底可不可以被修改 2.元组--tuple ()/(1,) 2.1创建和访问一个元组 如果创建一个空元组,直接使用小括号即可; 如果要创建的元组中只有一个元素,要在它的后面加上一个逗号‘,’。 >...
  • 理解scala的元组类型

    2017-08-06 11:22:49
    scala> classOf[(Int,String)] res10: Class[(Int, String)] = class scala.Tuple2scala> classOf[(String,String)] res11: Class[(String, String)] = class scala.Tuple2scala> res10==res11 ...
  • swift元组类型

    2015-12-29 09:54:13
    // let result = "\(name)的年龄是\(age)岁!"  let result = "\(name)的年龄是\(age)岁" ...元组是oc种没有的数据类型,与数组类似都是表示一组数据的集合 var定义的元祖是可变元组 let定义的元组
  • python元组类型

    2016-09-18 21:53:36
    元组是和列表非常相似...但功能上却有很大区别——元组是不可变类型。不可变给元组带来什么影响不可变并不是坏事,当我们把数据传递给一个不熟悉的API时,可以确保我们的数据不被改变(当然可以通过list()函数转换)。...
  • Scala | Tuple - 元组类型

    2020-08-03 10:23:48
    Tuple - 元组类型 与列表一样,元组也是不可变的,但与列表不同的是元组可以包含不同类型的元素。 目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合,或者扩展元组。 元组取值,通过._下标取值;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 255,252
精华内容 102,100
关键字:

元组类型

友情链接: uqes.rar