精华内容
下载资源
问答
  • tuple类型

    2021-01-16 00:02:07
    文章目录前言一、对于tuple的使用...所以c++标准库在c++11里添加了tuple这样一个类模板,通过它可以进行不同类型的数据的打包从而可以方便的实现函数的多返回值。 一、对于tuple的使用实例: #include <iostream>


    前言

    在c++当中没有提供一个方便的数据结构可以实现不同类型的对象的打包。唯一能够实现的操作也是通过struct定义不同的类型的成员进行打包,这样在处理不同的类型的时候都要写上一遍不同的定义使用起来很麻烦。所以c++标准库在c++11里添加了tuple这样一个类模板,通过它可以进行不同类型的数据的打包从而可以方便的实现函数的多返回值。


    一、对于tuple的使用实例:

    #include <iostream>
    #include <tuple>
    #include <vector>
    #include <string>
    using namespace std;
    int main()
    {
        tuple<string, unsigned int, double> Zhouz;
        Zhouz = make_tuple("zz", 24, 60.0);
    
        //或者利用typedef来简化
        typedef tuple<string, unsigned int, double> Human;
    
        Human Yic("zz", 24, 60.0);
    
        vector<Human> vecHuman;
        vecHuman.push_back(Zhouz);
        vecHuman.push_back(Yic);
    
        //获取tuple数据组变量zhouz中的第一个数据名字
        cout<<"姓名:"<<get<0>(Zhouz)<<endl;
    
        get<1>(Zhouz) += 1;
    
        cout<<"年龄:"<<get<1>(Zhouz)<<endl;
    
        cout<<"体重:"<<get<2>(Zhouz)<<endl;
    
        return 0;
    }
    

    二、tuple支持的操作:

    可以通过模板参数的指定定义一个tuple类型的对象。
    也可以方便的使用make_tuple根据传入的对象的类型进行直接的创建。这个函数自然是个模板函数使用了参数的类型推导机制。
    可以通过模板函数get获取tuple对象第i个元素的引用。
    通过两个模板类可以获取tuple对象的元素的个数以及第i个元素的类型。
    通过c++11的decltype可以获取某个tuple对象的实际类型。

    C++ 11中引入的tuple是一个N元组。它相当于有N个成员的结构体,只不过这个结构体的成员都是匿名的。tuple中有两个特殊的函数,一个是head(),用于获取第一个成员的值,另一个是tail(),用于获取剩下所有成员的值,tail()本身又是一个tuple。这样,如果我们想取tuple中第二个成员的值,则可以先取tail()的值,再取tail()的head()的值。当然,这样使用的话比较麻烦,所以C++ 11提供了get函数通过索引来获取tuple中某个成员的值。另外,通过make_tuple可以很方便地构造一个tuple对象。

    三、实现tuple:

    tuple是一个N元组,而N的个数是没有限制的,也就是说,tuple可以包含0个、1个、2个或更多的元素,每个元素的类型则通过模板参数指定。那么,就是通过可变参数模板,可以做到这些。
    虽然tuple已近可以实现不同的数据类型的对象的打包,但是还是不能动态的往里头添加不同的对象,因为这个tuple的类型已近定了无法再给这个对象添加新的成员。

    展开全文
  • tuple 类型

    千次阅读 2018-08-26 21:24:43
    STL当中的tuple类型 主要内容 起因 用过python等动态语言的人都应该知道,这类的语言函数都可以返回多个值,每个值可以是不同的类型的对象。同样Java和python当中都有可以装载不同类型的变长数组存在,...

    写在前面

    STL当中的tuple类型

    主要内容

    起因

    用过python等动态语言的人都应该知道,这类的语言函数都可以返回多个值,每个值可以是不同的类型的对象。同样Java和python当中都有可以装载不同类型的变长数组存在,Java当中是容器Array,python当中是列表list。
    在c++当中没有提供一个方便的数据结构可以像这样实现不同类型的对象的打包。唯一能够实现的操作也是通过struct定义不同的类型的成员进行打包,这样在处理不同的类型的时候都要写上一遍不同的定义使用起来确实麻烦。

    tuple

    所以c++标准库在c++11里添加了tuple这样一个类模板,通过它可以进行不同类型的数据的打包从而可以方便的实现函数的多返回值。

    下面是对于tuple的使用实例:

    #include <iostream>
    #include <tuple>
    #include <vector>
    #include <string>
    using namespace std;
    int main()
    {
        tuple<string, unsigned int, double> Zhouz;
        Zhouz = make_tuple("zz", 24, 60.0);
    
        //或者利用typedef来简化
        typedef tuple<string, unsigned int, double> Human;
    
        Human Yic("zz", 24, 60.0);
    
        vector<Human> vecHuman;
        vecHuman.push_back(Zhouz);
        vecHuman.push_back(Yic);
    
        //获取tuple数据组变量zhouz中的第一个数据名字
        cout<<"姓名:"<<get<0>(Zhouz)<<endl;
    
        get<1>(Zhouz) += 1;
    
        cout<<"年龄:"<<get<1>(Zhouz)<<endl;
    
        cout<<"体重:"<<get<2>(Zhouz)<<endl;
    
        return 0;
    }

    tuple支持的操作:

    可以通过模板参数的指定定义一个tuple类型的对象。
    也可以方便的使用make_tuple根据传入的对象的类型进行直接的创建。这个函数自然是个模板函数使用了参数的类型推导机制。
    可以通过模板函数get获取tuple对象第i个元素的引用。
    通过两个模板类可以获取tuple对象的元素的个数以及第i个元素的类型。
    通过c++11的decltype可以获取某个tuple对象的实际类型。

    C++ 11中引入的tuple是一个N元组。它相当于有N个成员的结构体,只不过这个结构体的成员都是匿名的。tuple中有两个特殊的函数,一个是head(),用于获取第一个成员的值,另一个是tail(),用于获取剩下所有成员的值,tail()本身又是一个tuple。这样,如果我们想取tuple中第二个成员的值,则可以先取tail()的值,再取tail()的head()的值。当然,这样使用的话比较麻烦,所以C++ 11提供了get函数通过索引来获取tuple中某个成员的值。另外,通过make_tuple可以很方便地构造一个tuple对象。


    tuple是如何实现的?

    前面说过,tuple是一个N元组,而N的个数是没有限制的,也就是说,tuple可以包含0个、1个、2个或更多的元素,每个元素的类型则通过模板参数指定。那么,tuple是如何做到这些的呢?答案是可变参数模板。
    虽然tuple已近可以实现不同的数据类型的对象的打包,但是还是不能动态的往里头添加不同的对象,因为这个tuple的类型已近定了无法再给这个对象添加新的成员。

    展开全文
  • C++中tuple类型

    2021-07-25 02:31:29
    但是每个确定的tuple类型的成员数目是固定的。 tuple容器(元组), 是表示元组容器, 是不包含任何结构的,快速而低质(粗制滥造, quick and dirty)的, 可以用于函数返回多个返回值; tuple容器, 可以使用直接初始化, 和...

    tuple是C++11新标准里的类型。它是一个类似pair类型的模板。pair类型是每个成员变量各自可以是任意类型,但是只能有俩个成员,而tuple与pair不同的是它可以有任意数量的成员。但是每个确定的tuple类型的成员数目是固定的。

    tuple容器(元组), 是表示元组容器, 是不包含任何结构的,快速而低质(粗制滥造, quick and dirty)的, 可以用于函数返回多个返回值;

    tuple容器, 可以使用直接初始化, 和"make_tuple()"初始化, 访问元素使用"get<>()"方法, 注意get里面的位置信息, 必须是常量表达式(const expression);

    可以通过"std::tuple_size<decltype(t)>::value"获取元素数量; "std::tuple_element<0, decltype(t)>::type"获取元素类型;

    如果tuple类型进行比较, 则需要保持元素数量相同, 类型可以比较, 如相同类型, 或可以相互转换类型(int&double);

    无法通过普通的方法遍历tuple容器, 因为"get<>()"方法, 无法使用变量获取值; 

    tuple是一个固定大小的不同类型值的集合,是泛化的std::pair。和c#中的tuple类似,但是比c#中的tuple强大得多。我们也可以把他当做一个通用的结构体来用,不需要创建结构体又获取结构体的特征,在某些情况下可以取代结构体使程序更简洁,直观。 

    基本用法  

    当我们希望将一些不同类型的数据和成单一对象时,可能大家会想到结构体(类),tuple是一种比结构体来的更加方便的类型 

    构造一个tuple  

    tuple<const char*, int>tp = make_tuple(sendPack,nSendSize); //构造一个tuple

    这个tuple等价于一个结构体 

    struct A
    {
        char* p;
        int len;
    };

     用tuple<const char*, int>tp就可以不用创建这个结构体了,而作用是一样的,是不是更简洁直观了。还有一种方法也可以创建元组,用std::tie,它会创建一个元组的左值引用。

    auto tp = return std::tie(1, "aa", 2);
    //tp的类型实际是:
    std::tuple<int&,string&, int&>

    再看看如何获取它的值:

    const char* data = std::get<0>(); //获取第一个值
    int len = std::get<1>(); //获取第二个值

     以下是两个简单demo

    demo1:

    #include<iostream>
    //定义在此头文件下
    #include<tuple>
     
    using namespace std;
     
    int main(void)
    {
        tuple<int,int,float> tp(1,2,3.1);
     
        cout<<"第一个元素为:"<<get<0>(tp)<<endl;
        cout<<"第二个元素为:"<<get<1>(tp)<<endl;
        cout<<"第三个元素为:"<<get<2>(tp)<<endl;
     
        return 0;
    }

     demo2:

    /*eclipse cdt, gcc 4.8.1*/  
      
    #include <iostream>  
    #include <vector>  
    #include <string>  
    #include <tuple>  
      
    using namespace std;  
      
    std::tuple<std::string, int>  
    giveName(void)  
    {  
        std::string cw("Caroline");  
        int a(2023);  
        std::tuple<std::string, int> t = std::make_tuple(cw, a);  
        return t;  
    }  
      
    int main()  
    {  
        std::tuple<int, double, std::string> t(64, 128.0, "Caroline");  
        std::tuple<std::string, std::string, int> t2 =  
                std::make_tuple("Caroline", "Wendy", 1992);  
      
        //返回元素个数  
        size_t num = std::tuple_size<decltype(t)>::value;  
        std::cout << "num = " << num << std::endl;  
      
        //获取第1个值的元素类型  
        std::tuple_element<1, decltype(t)>::type cnt = std::get<1>(t);  
        std::cout << "cnt = " << cnt << std::endl;  
      
        //比较  
        std::tuple<int, int> ti(24, 48);  
        std::tuple<double, double> td(28.0, 56.0);  
        bool b = (ti < td);  
        std::cout << "b = " << b << std::endl;  
      
        //tuple作为返回值  
        auto a = giveName();  
        std::cout << "name: " << get<0>(a)  
                << " years: " << get<1>(a) << std::endl;  
      
        return 0;  
    }

    输出结果:

    num = 3  
    cnt = 128  
    b = 1  
    name: Caroline years: 2023 
    

      还有一种方法也可以获取元组的值,通过std::tie解包tuple 

    int x,y;
    string a;
    std::tie(x,a,y) = tp; 

     通过tie解包后,tp中三个值会自动赋值给三个变量。

    解包时,我们如果只想解某个位置的值时,可以用std::ignore占位符来表示不解某个位置的值。比如我们只想解第三个值时:

    std::tie(std::ignore,std::ignore,y) = tp; //只解第三个值了

    还有一个创建右值的引用元组方法:forward_as_tuple。

    std::map<int, std::string> m;    
    m.emplace(std::piecewise_construct, 
        std::forward_as_tuple(10), 
        std::forward_as_tuple(20, 'a'));

    它实际上创建了一个类似于std::tuple<int&&, std::string&&>类型的tuple。

    我们还可以通过tuple_cat连接多个tupe

    int main()
    {
        std::tuple<int, std::string, float> t1(10, "Test", 3.14);
        int n = 7;
        auto t2 = std::tuple_cat(t1, std::make_pair("Foo", "bar"), t1, std::tie(n));
        n = 10;
        print(t2);
    }

    输出结果:

    (10, Test, 3.14, Foo, bar, 10, Test, 3.14, 10)
    

    到这里tuple的用法介绍完了,是不是很简单,也很容易使用,相信你使用它之后就离不开它了。我前面说过tuple是简约而不简单。它有很多高级的用法。它和模板元关系密切,要介绍它的高级用法的时候,读者需要一定的模板元基础,如果你只是把它当一个泛型的pair去使用时,这部分可以不看,如果你想用它高级用法的时候就往下看。让我们要慢慢揭开tuple神秘的面纱。

    tuple所支持的操作

    操作说明
    make_tuple(v1,v2,v3,v4…vn)返回一个给定初始值初始化的tuple,类型从初始值推断
    t1 == t2当俩个tuple具有相同数量的成员且成员对应相等时
    t1 != t2与上一个相反
    get(t)返回t的第i个数据成员
    tuple_size::value给定了tuple中成员的数量

    g++ 编译器报错不是std对象时,要在后面加上 -std=c++11,  对接nosql数据库。

    tuple的高级用法

    获取tuple中某个位置元素的类型

    通过std::tuple_element获取元素类型。

    template<typename Tuple>
    void Fun(Tuple& tp)
    {
        std::tuple_element<0,Tuple>::type first = std::get<0> (mytuple);
        std::tuple_element<1,Tuple>::type second = std::get<1> (mytuple);
    }

    获取tuple中元素的个数:

    tuple t;
    
    int size = std::tuple_size<decltype(t))>::value;

    遍历tuple中的每个元素

    因为tuple的参数是变长的,也没有for_each函数,如果我们想遍历tuple中的每个元素,需要自己写代码实现。比如我要打印tuple中的每个元素。

    template<class Tuple, std::size_t N>
    struct TuplePrinter {
        static void print(const Tuple& t)
        {
            TuplePrinter<Tuple, N - 1>::print(t);
            std::cout << ", " << std::get<N - 1>(t);
        }
    };
    
    template<class Tuple>
    struct TuplePrinter<Tuple, 1>{
        static void print(const Tuple& t)
        {
            std::cout << std::get<0>(t);
        }
    };
    
    template<class... Args>
    void PrintTuple(const std::tuple<Args...>& t)
    {
        std::cout << "(";
        TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
        std::cout << ")\n";
    }

    根据tuple元素值获取其对应的索引位置

    namespace detail
    {
        template<int I, typename T, typename... Args>
        struct find_index
        {
            static int call(std::tuple<Args...> const& t, T&& val)
            {
                return (std::get<I - 1>(t) == val) ? I - 1 :
                    find_index<I - 1, T, Args...>::call(t, std::forward<T>(val));
            }
        };
    
        template<typename T, typename... Args>
        struct find_index<0, T, Args...>
        {
            static int call(std::tuple<Args...> const& t, T&& val)
            {
                return (std::get<0>(t) == val) ? 0 : -1;
            }
        };
    }
    
    template<typename T, typename... Args>
    int find_index(std::tuple<Args...> const& t, T&& val)
    {
        return detail::find_index<0, sizeof...(Args) - 1, T, Args...>::
               call(t, std::forward<T>(val));
    }
    
    int main()
    {
        std::tuple<int, int, int, int> a(2, 3, 1, 4);
        std::cout << find_index(a, 1) << std::endl; // Prints 2
        std::cout << find_index(a, 2) << std::endl; // Prints 0
        std::cout << find_index(a, 5) << std::endl; // Prints -1 (not found)
    }

    展开tuple,并将tuple元素作为函数的参数。这样就可以根据需要对tuple元素进行处理了

    #include <tuple>
    #include <type_traits>
    #include <utility>
    
    template<size_t N>
    struct Apply {
        template<typename F, typename T, typename... A>
        static inline auto apply(F && f, T && t, A &&... a)
        -> decltype(Apply<N-1>::apply(
            ::std::forward<F>(f), ::std::forward<T>(t),
            ::std::get<N-1>(::std::forward<T>(t)), 
            ::std::forward<A>(a)...
        ))
        {
            return Apply<N-1>::apply(::std::forward<F>(f), 
                ::std::forward<T>(t),
                ::std::get<N-1>(::std::forward<T>(t)), 
                ::std::forward<A>(a)...
            );
        }
    };
    
    template<>
    struct Apply<0> {
        template<typename F, typename T, typename... A>
        static inline auto apply(F && f, T &&, A &&... a)
        -> decltype(::std::forward<F>(f) 
        (::std::forward<A>(a)...))
        {
            return ::std::forward<F>(f)(::std::forward<A> 
            (a)...);
        }
    };
    
    template<typename F, typename T>
    inline auto apply(F && f, T && t)
    -> decltype(Apply< ::std::tuple_size<typename ::std::decay<T>::type>::value>::apply(::std::forward<F>(f), 
    ::std::forward<T>(t)))
    {
        return Apply< ::std::tuple_size<
        typename ::std::decay<T>::type
        >::value>::apply(::std::forward<F>(f), 
        ::std::forward<T>(t));
    }
    
    void one(int i, double d)
    {
        std::cout << "function one(" << i << ", " << d << ");\n";
    }
    
    int two(int i)
    {
        std::cout << "function two(" << i << ");\n";
        return i;
    }
    
    //测试代码
    int main()
    {
        std::tuple<int, double> tup(23, 4.5);
        apply(one, tup);
    
        int d = apply(two, std::make_tuple(2));
    
        return 0;
    }

    看到这里,想必大家对tuple有了一个全面的认识了吧,怎么样,它是简约而不简单吧。对模板元不熟悉的童鞋可以不看tuple高级用法部分,不要为看不懂而捉急,没事的,高级部分一般用不到,知道基本用法就够用了。

    tuple和vector比较:

    vector只能容纳同一种类型的数据,tuple可以容纳任意类型的数据;

    vector和variant比较:

    二者都可以容纳不同类型的数据,但是variant的类型个数是固定的,而tuple的类型个数不是固定的,是变长的,更为强大。

    C++ pair 点对 

    1 pair的应用

    pair是将2个数据组合成一个数据,当需要这样的需求时就可以使用pair,如stl中的map就是将key和value放在一起来保存。另一个应用是,当一个函数需要返回2个数据的时候,可以选择pair。 pair的实现是一个结构体,主要的两个成员变量是first second 因为是使用struct不是class,所以可以直接使用pair的成员变量。

    其标准库类型--pair类型定义在#include <utility>头文件中,定义如下:

    类模板:template<class T1,class T2> struct pair

    参数:T1是第一个值的数据类型,T2是第二个值的数据类型。

    功能:pair将一对值(T1和T2)组合成一个值,

            这一对值可以具有不同的数据类型(T1和T2),

            两个值可以分别用pair的两个公有函数first和second访问。

    定义(构造函数):

    pair<T1, T2> p1;            //创建一个空的pair对象(使用默认构造),它的两个元素分别是T1和T2类型,采用值初始化。
    pair<T1, T2> p1(v1, v2);    //创建一个pair对象,它的两个元素分别是T1和T2类型,其中first成员初始化为v1,second成员初始化为v2。
    make_pair(v1, v2);          // 以v1和v2的值创建一个新的pair对象,其元素类型分别是v1和v2的类型。
    p1 < p2;                    // 两个pair对象间的小于运算,其定义遵循字典次序:如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。
    p1 == p2;                  // 如果两个对象的first和second依次相等,则这两个对象相等;该运算使用元素的==操作符。
    p1.first;                   // 返回对象p1中名为first的公有数据成员
    p1.second;                 // 返回对象p1中名为second的公有数据成员

     2 pair的创建和初始化

     pair包含两个数值,与容器一样,pair也是一种模板类型。但是又与之前介绍的容器不同;

    在创建pair对象时,必须提供两个类型名,两个对应的类型名的类型不必相同 

    
    pair<string, string> anon;        // 创建一个空对象anon,两个元素类型都是string
    pair<string, int> word_count;     // 创建一个空对象 word_count, 两个元素类型分别是string和int类型
    pair<string, vector<int> > line;  // 创建一个空对象line,两个元素类型分别是string和vector类型

    当然也可以在定义时进行成员初始化:

    pair<string, string> author("James","Joy");    // 创建一个author对象,两个元素类型分别为string类型,并默认初始值为James和Joy。
    pair<string, int> name_age("Tom", 18);
    pair<string, int> name_age2(name_age);    // 拷贝构造初始化

     pair类型的使用相当的繁琐,如果定义多个相同的pair类型对象,可以使用typedef简化声明:

    typedef pair<string,string> Author;
    Author proust("March","Proust");
    Author Joy("James","Joy");

     变量间赋值:

    pair<int, double> p1(1, 1.2);
    pair<int, double> p2 = p1;     // copy construction to initialize object
    pair<int, double> p3;
    p3 = p1;    // operator =

     3 pair对象的操作 

    访问两个元素操作可以通过first和sencond访问:

    pair<int ,double> p1;
     
    p1.first = 1;
     
    p1.second = 2.5;
     
    cout<<p1.first<<' '<<p1.second<<endl;
     
    //输出结果:1 2.5
     
     
    string firstBook;
    if(author.first=="James" && author.second=="Joy")
        firstBook="Stephen Hero";

    4 make_pair函数(生成新的pair对象)

    还可以利用make_pair创建新的pair对象 

     pair<int, double> p1;
     p1 = make_pair(1, 1.2);
     
    cout << p1.first << p1.second << endl;
     
    //output: 1 1.2
     
    int a = 8;
     
    string m = "James";
     
    pair<int, string> newone;
     
    newone = make_pair(a, m);
    cout << newone.first << newone.second << endl;
     
    //output: 8 James

    template pair make_pair(T1 a, T2 b) { return pair(a, b); }

    很明显,我们可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。 一般make_pair都使用在需要pair做参数的位置,可以直接调用make_pair生成pair对象很方便,代码也很清晰。 另一个使用的方面就是pair可以接受隐式的类型转换,这样可以获得更高的灵活度。灵活度也带来了一些问题如:

    std::pair<int, float>(1, 1.1);

    std::make_pair(1, 1.1);

    是不同的,第一个就是float,而第2个会自己匹配成double。

    类模板:template <class T1, class T2> struct pair

    参数:T1是第一个值的数据类型,T2是第二个值的数据类型。

    功能:pair将一对值组合成一个值,这一对值可以具有不同的数据类型(T1和T2),两个值可以分别用pair的两个公有函数first和second访问。

    具体用法:

    1.定义(构造):

     pair<int, double> p1;  //使用默认构造函数
     pair<int, double> p2(1, 2.4);  //用给定值初始化
     pair<int, double> p3(p2);  //拷贝构造函数

    2.访问两个元素(通过first和second)

    pair<int, double> p1;  //使用默认构造函数
    p1.first = 1;
    p1.second = 2.5;
    cout << p1.first << ' ' << p1.second << endl;

    输出结果:1 2.5

    赋值operator = :

    (1)利用make_pair

    pair<int, double> p1;
    p1 = make_pair(1, 1.2);

    (2)变量间赋值:

    pair<int, double> p1(1, 1.2);
    pair<int, double> p2 = p1;

    5 通过tie获取pair元素值

    在某些清况函数会以pair对象作为返回值时,可以直接通过std::tie进行接收。比如:

    std::pair<std::string, int> getPreson() {
        return std::make_pair("Sven", 25);
    }
     
    int main(int argc, char **argv) {
        std::string name;
        int ages;
     
        std::tie(name, ages) = getPreson();
     
        std::cout << "name: " << name << ", ages: " << ages << std::endl;
     
        return 0;
    }

    Pair类型概述

    pair是一种模板类型,其中包含两个数据值,两个数据的类型可以不同,基本的定义如下:

    pair<int, string> a;

    表示a中有两个类型,第一个元素是int型的,第二个元素是string类型的,如果创建pair的时候没有对其进行初始化,则调用默认构造函数对其初始化。

    pair<string, string> a("James", "Joy");

    也可以像上面一样在定义的时候直接对其初始化。

    由于pair类型的使用比较繁琐,因为如果要定义多个形同的pair类型的时候,可以时候typedef简化声明:

    typedef pair<string, string> author;
    
    author pro("May", "Lily");
    
    author joye("James", "Joyce");

    Pair对象的操作

    • 对于pair类,由于它只有两个元素,分别名为first和second,因此直接使用普通的点操作符即可访问其成员

    pair<string, string> a("Lily", "Poly"); 
    
    string name;
    
    name = a.second;
    • 生成新的pair对象

    可以使用make_pair对已存在的两个数据构造一个新的pair类型:

    int a = 8;
    
    string m = "James";
    
    pair<int, string> newone;
    
    newone = make_pair(a, m);

    参考:

            https://www.cnblogs.com/huangfuyuan/p/9238598.html

            https://www.cnblogs.com/lsgxeva/p/8250879.html

            https://www.cnblogs.com/qicosmos/p/3318070.html 

            pair

            https://blog.csdn.net/sevenjoin/article/details/81937695

    展开全文
  • 【Python】Python之tuple类型 今天,我们开始学习Python中的另一种类型——tuple类型。tuple是另一种有序的列表,中文翻译为“ 元组 ”,tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。 Python之...

    【Python】Python之tuple类型

    今天,我们开始学习Python中的另一种类型——tuple类型。tuple是另一种有序的列表,中文翻译为“ 元组 ”,tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。

    Python之创建tuple

    我们同样的使用班级里同学的名字来创建tuple,用tuple表示如下:

    mates = ('小明','小红','小黑','小白')
    print(mates)
    

    创建tuple和创建list唯一不同之处是用( )替代了[ ]。
    现在,这个 mates 创建完之后就不能改变了,tuple没有 append()方法和remove()方法,也没有insert()方法和pop()方法。所以,新同学没法直接往 tuple 中添加,老同学想退出 tuple 也不行。

    获取 tuple 元素的方式和 list 是一模一样的,我们可以正常使用 t[0],t[-1]等索引方式来访问元素,但是不能赋值成别的元素。

    mates = ('小明','小红','小黑','小白')
    print(mates[0])
    print(mates)
    

    测试如下:
    在这里插入图片描述
    倘若我们给tuple元素赋值成其他的元素,我们来看一下结果:

    mates = ('小明','小红','小黑','小白')
    mates[2]= '小蓝'
    print(mates)
    

    测试结果:
    在这里插入图片描述
    说明tuple类型中的元素一旦创建就不能再修改了。

    Python之创建单元素tuple

    其实tuple和list一样,可以包含 0 个、1个和任意多个元素。包含多个元素的 tuple,我们在上文已经创建过了。

    那包含 0 个元素的 tuple,也就是空tuple,其实可以直接用 ()表示:

    mates = ()
    print(mates)
    

    那我们来试试创建包含1个元素的 tuple 吧。

    mates = ('小明')
    print(mates)
    

    测试结果:
    在这里插入图片描述
    输出结果好像哪里不对!mates的输出好像不是tuple类型的( ‘小明’ ) ,而是字符串 小明。那为什么会这样呢?
    因为()既可以表示tuple,又可以作为括号表示运算时的优先级,mates = (‘小明’)被Python解释器看做了字符串以后输出也会截然不同,导致我们得到的不是tuple的输出,而是字符串 小明。

    正是因为用( )定义单元素的tuple有歧义,所以 Python 规定,单元素 tuple 要多加一个逗号“,”,这样就避免了歧义:

    mates = ('小明',)
    print(mates)
    

    测试结果:
    在这里插入图片描述
    因此Python在打印单元素tuple时,也自动添加了一个“,”,为了更明确地告诉你这是一个tuple类型。

    而多元素的 tuple 加不加这个额外的“,”,效果其实是一样的:

    mates = ('小明','小红','小黑','小白',)
    print(mates)
    

    测试结果如下:
    在这里插入图片描述

    Python之“七十二变”的tuple

    前面我们看到了tuple一旦创建就不能修改。现在,我们来看一个“可以变化”的tuple:

    mates = ('小明','小红',['小黑','小白'])
    a = mates[2]
    a[0] = '小蓝'
    a[1] = '小绿'
    print(mates)
    

    测试结果如下:
    在这里插入图片描述
    我们会明显的发现mates里面的元素发生了替换,我们注意到 mates 中有 3 个元素:‘小明’,'小红’和一个list:[‘小黑’,‘小白’]。list作为一个整体是tuple的第3个元素。
    list对象可以通过 mates[2] 来拿到,然后我们把list中的的两个元素改成为小黑和小白,就会出现测试中的结果。

    但是不是说tuple一旦定义后就不可变了吗,为什么现在又变了呢?
    别急,接下来我会使用图文来解释 刚才的过程:
    在这里插入图片描述
    当我们把list的元素’小黑’和’小白’修改为’小蓝’和’小绿’后,tuple变为:
    在这里插入图片描述
    从表面上看tuple的元素确实变了,但其实变的不是 tuple 中的元素,而是 list 中的元素。
    tuple一开始指向的list并没有改成别的list,所以tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向’小明’,就不能改成指向’小红’,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

    理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。

    思考下面例题
    定义了tuple:
    t = (‘a’, ‘b’, [‘A’, ‘B’])
    由于 t 包含一个list元素,导致tuple的内容是可变的。能否修改上述代码,让tuple内容不可变?
    解答:[‘A’, ‘B’]是list类型,因此内容可变,但tuple类型的(‘A’, ‘B’)的内容是不可变的。

    l = ('a', 'b', ['A', 'B'])
    t = ('a', 'b', ('A', 'B'))
    print(l)
    print(t)
    

    所以通过使用把tuple中的所有的 [ ] 改成 ( ) ,即可使tuple中的所有元素都可以真正的固定下来。

    展开全文
  • 今天来聊聊Python的tuple(元组)类型,如果用一句话概括,那tuple类型就是“只读”的list,因为它有list类型大部分方法和特性。那你可能要问,为什么还要有tuple类型?原因就是正因为它的“只读”特性,在操作速度和...
  • C++11的tuple类型

    2020-07-28 09:32:34
    tuple是一种数据类型,叫做元组,它类似于我们平时使用的struct结构体,可以将不同的数据类型放入到tuple中。 和tuple相关的函数 1.make_tuple:它是用来创建一个tuple的 auto tup1 = std::make_tuple("Hello Wrold!...
  • C++ 11之tuple类型

    2018-03-18 09:07:34
    tuple看似简单,其实它是简约而不简单,可以说它是c++11中一个既简单又复杂的东东,关于它简单的一面是它很容易使用,复杂的一面是它内部隐藏了太多细节,要揭开它神秘的面纱时又比较困难。  tuple是一个固定大小....
  • 今天小编就为大家分享一篇python 提取tuple类型值中json格式的key值方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Flink中Tuple类型

    千次阅读 2020-06-22 19:54:48
    Types.TUPLE(TypeInformation.of(Long.class),TypeInformation.of(Integer.class));
  • Tuple元组类型使用以及Lambda编写flink程序正确姿势(方法与避坑)
  • 使用pymysql,从mysql查询数据,返回结果是tuple类型 def query_kdata(self,code): if self.connect is None: return None # 得到一个可以执行SQL语句的光标对象 cursor = self.connect.cursor() ...
  • python的List和Tuple类型

    2018-05-18 13:18:26
    python入门基础语法,python的List和Tuple类型知识点及代码举例
  • 使用数据类型定义元组时: !... !... 如果里面是单个数字,不管后面加不加逗号,都会报错,提示int 不可...请问可以讲一下类型转换时,tuple转化其他类型的过程是什么?最好从原理上讲一下为什么上述问题会出错?谢谢!
  • c++ tuple类型

    千次阅读 2016-04-09 15:58:25
    c++ tuple类型个人笔记 了解tuple: - tuple是模板,tuple所有成员都是public的 - 使用tuple的相关操作,需要包含头文件tuple。 - 希望将数据组合成单一对象时,使用tuple非常有用。(快而随意的数据结构) -...
  • C++STL之tuple类型_tie函数_get函数

    千次阅读 2020-03-08 22:21:22
    tuple:元组 1. std::tuple https://zh.cppreference.com/w/cpp/utility/tuple (C++11 起) 类模板 std::tuple 是固定大小的异类值汇集。它是 std::pair 的推广。 example: std::tuple<int, int> foo_...
  • tuple是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。同样是表示班里同学的名称,用tuple表示如下:&gt;&gt;&gt; t = ('Adam', 'Lisa',...
  • 不同tuple类型的成员类型可以不相同,tuple可以有任意数量的成员 每个确定的tuple类型的成员数目是固定的 定义和初始化tuple 注意:第二个为每个成员提供初始值的初始化方式,由于对应的构造函数是explicit的,...
  • 目录 元组tuple类型内置方法 用途 定义 常用操作+内置方法 优先掌握 存一个值or多个值 有序or无序 可变or不可变 元组tuple类型内置方法 元组是不可变的...
  • 使用python 写了一个函数,return 了两个返回值比如 return a,b 于是返回的a,b 是tuple类型,比如值是actual。那么,得到a,b分别是actual[0] ,actual[1]这样的。而目前,actual[0]的值是这样的: {“code”:”m...
  • 1、tuple基础 tuple是另一种有序的列表,中文翻译为“ 元组 ”。tuple 和 list 非常类似,但是,tuple一旦创建完毕,就不能修改了。同样是表示班里同学的名称,用tuple表示如下:>>> t = ('Adam', 'Lisa', 'Bart')...
  • C#的元组Tuple类型

    千次阅读 2013-06-06 18:54:43
    using System; using System.Collections; using System.Collections.Generic; namespace Csharp { class Program ... //元组Tuple类型 public static Tuple Divide(int dividend, int divisor)
  • Scala Tuple类型

    2016-07-09 22:42:00
    Tuple可以作为集合存储不同类型的数据,初始化实例如下: ...Scala函数还可以返回Tuple类型的值,并接收,如: val (first,second,third,forth) = tuple 跟Tuple无关但是挺有意思的东西,顺便...
  • C++笔记 17.1 tuple类型

    2020-09-18 21:02:34
    primer C++笔记 tuple类型 #include 定义和初始化tuple 访问tuple的成员 得到类型名称:typeid(vec).name() 关系和相等运算符 使用tuple可以返回多个值
  • std::tuple类型

    2021-02-16 23:47:53
    tuple:元组 1. std::tuple https://zh.cppreference.com/w/cpp/utility/tuple (C++11 起) 类模板std::tuple是固定大小的异类值汇集。它是std::pair的推广。 example: std::tuple<int, int> foo_tuple...
  • 既可以表示tuple,又可以作为括号表示运算时的优先级,结果 (1) 被Python解释器计算出结果 1,导致我们得到的不是tuple,而是整数 1。 正是因为用()定义单元素的tuple有歧义,所以 Python 规定,单元素 tuple 要...
  • python元组(tuple类型

    千次阅读 2018-12-07 18:05:57
    1.元组类型tuple)与列表类型对比 2.快速访问元组 3.涉及修改元组数据的相关函数 4.元组(tuple)与列表(list)转换
  • Object [] parg = {input , //测试数据 "F:\\shuju\\model.txt... 我把tuple类型的数据input和String类型的数据同时放在object数组中,现在我要用数组中的input,我怎么能把object类型的数据强制转换为tuple类型
  • Tuple类型的使用

    2016-05-23 19:15:00
    1.什么是Tuple Tuple类型,可以存放任何类型 2.Tuple有哪些分类 .Net 4.0 定义了8个泛型Tuple类,和一个Tuple静态类 3.Tuple的使用 转载于:https://www.cnblogs.com/kimisme/p/5521131.html...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,843
精华内容 53,537
关键字:

tuple类型