精华内容
下载资源
问答
  • map函数

    千次阅读 多人点赞 2019-04-21 22:10:44
    map函数 map函数:在可迭代对象上映射函数 map函数在python2.0中,相关内置函数map在传入None作为函数参数时,会以类似方式把序列的元素配对起来。如果各个参数长度不等,那么map函数会用None补齐较短的序列(不是...

    map函数

    • map函数:在可迭代对象上映射函数
    • map函数在python2.0中,相关内置函数map在传入None作为函数参数时,会以类似方式把序列的元素配对起来。如果各个参数长度不等,那么map函数会用None补齐较短的序列(不是按照最短的序列长度截断),python3.0中不再支持
    • 在python3.0中,map会先输入一个函数参数,以及一个或多个序列参数,然后用从序列中取出的并行元素来调整,最后把结果收集起来并返回(map是一个值生成器,必须传入list从而一次性收集并显示其结果),返回的是迭代器

    1. 函数语法:

    map(function,iterable)
    function:函数
    iterable:一个或者多个序列

    2. map()会根据提供的函数对指定的序列做映射

    • 第一个参数function()以参数序列中的每一个元素调用function函数,返回包含每次function函数返回值的新列表
    >>> def square(x):
    >>>     return x ** 2
    >>> map(square,[1,2,3,4,5])
    <map at 0xbd26f28>
    >>> list(map(square,[1,2,3,4,5]))
    [1, 4, 9, 16, 25]
    
    >>> def add(x,y,z):
    >>>     return x + y + z
    >>> list1 = [1,2,3]
    >>> list2 = [1,2,3,4]
    >>> list3 = [1,2,3,4,5]
    >>> res = map(add,list1,list2,list3)  #有截断功能,按最短的算
    >>> print(list(res)) #1+1+1,2+2+2,3+3+3
    [3, 6, 9]
    
    展开全文
  • Map函数

    千次阅读 2018-02-03 08:59:10
    一.Map概述 Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的...

    一.Map概述
    Map是STL的一个关联容器,它提供一对一(其中第一个可以称为关键字,每个关键字只能在map中出现一次,第二个可能称为该关键字的值)的数据处理能力,由于这个特性,它完成有可能在我们处理一对一数据的时候,在编程上提供快速通道。这里说下map内部数据的组织,map内部自建一颗红黑树(一种非严格意义上的平衡二叉树),这颗树具有对数据自动排序的功能,所以在map内部所有的数据都是有序的,后边我们会见识到有序的好处。
    下面举例说明什么是一对一的数据映射。比如一个班级中,每个学生的学号跟他的姓名就存在着一一映射的关系,这个模型用map可能轻易描述,很明显学号用int描述,姓名用字符串描述(本篇文章中不用char *来描述字符串,而是采用STL中string来描述),下面给出map描述代码:
    Map<int, string> mapStudent;
    1. map的构造函数
    map共提供了6个构造函数,这块涉及到内存分配器这些东西,略过不表,在下面我们将接触到一些map的构造方法,这里要说下的就是,我们通常用如下方法构造一个map:
    Map<int, string> mapStudent;
    2. 数据的插入
    在构造map容器后,我们就可以往里面插入数据了。这里讲三种插入数据的方法:
    第一种:用insert函数插入pair数据,下面举例说明(以下代码虽然是随手写的,应该可以在VC和GCC下编译通过,大家可以运行下看什么效果,在VC下请加入这条语句,屏蔽4786警告 #pragma warning (disable:4786) )

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
      map<int, string>::iterator iter;
      for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    第二种:用insert函数插入value_type数据,下面举例说明

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(map<int, string>::value_type (1, “student_one”));
      mapStudent.insert(map<int, string>::value_type (2, “student_two”));
      mapStudent.insert(map<int, string>::value_type (3, “student_three”));
      map<int, string>::iterator iter;
      for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    第三种:用数组方式插入数据,下面举例说明

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent[1] = “student_one”;
      mapStudent[2] = “student_two”;
      mapStudent[3] = “student_three”;
      map<int, string>::iterator iter;
      for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    以上三种用法,虽然都可以实现数据的插入,但是它们是有区别的,当然了第一种和第二种在效果上是完成一样的,用insert函数插入数据,在数据的插入上涉及到集合的唯一性这个概念,即当map中有这个关键字时,insert操作是插入数据不了的,但是用数组方式就不同了,它可以覆盖以前该关键字对应的值,用程序说明
    mapStudent.insert(map<int, string>::value_type (1, “student_one”));
    mapStudent.insert(map<int, string>::value_type (1, “student_two”));
    上面这两条语句执行后,map中1这个关键字对应的值是“student_one”,第二条语句并没有生效,那么这就涉及到我们怎么知道insert语句是否插入成功的问题了,可以用pair来获得是否插入成功,程序如下
    Pair<map<int, string>::iterator, bool> Insert_Pair;
    Insert_Pair = mapStudent.insert(map<int, string>::value_type (1, “student_one”));
    我们通过pair的第二个变量来知道是否插入成功,它的第一个变量返回的是一个map的迭代器,如果插入成功的话Insert_Pair.second应该是true的,否则为false。
    下面给出完成代码,演示插入成功与否问题

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
    Pair<map<int, string>::iterator, bool> Insert_Pair;
      Insert_Pair = mapStudent.insert(pair<int, string>(1, “student_one”));
      If(Insert_Pair.second == true)
      {
      Cout<<”Insert Successfully”<<endl;
      }
      Else
      {
      Cout<<”Insert Failure”<<endl;
      }
      Insert_Pair = mapStudent.insert(pair<int, string>(1, “student_two”));
      If(Insert_Pair.second == true)
      {
      Cout<<”Insert Successfully”<<endl;
      }
      Else
      {
      Cout<<”Insert Failure”<<endl;
      }
      map<int, string>::iterator iter;
      for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    大家可以用如下程序,看下用数组插入在数据覆盖上的效果

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent[1] = “student_one”;
      mapStudent[1] = “student_two”;
      mapStudent[2] = “student_three”;
      map<int, string>::iterator iter;
      for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    3. map的大小
    在往map里面插入了数据,我们怎么知道当前已经插入了多少数据呢,可以用size函数,用法如下:
    Int nSize = mapStudent.size();
    4. 数据的遍历
    这里也提供三种方法,对map进行遍历
    第一种:应用前向迭代器,上面举例程序中到处都是了,略过不表
    第二种:应用反相迭代器,下面举例说明,要体会效果,请自个动手运行程序

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
      map<int, string>::reverse_iterator iter;
      for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)
    {
      Cout<<iter->first<<” ”<<iter->second<<end;
    }
    }


    第三种:用数组方式,程序说明如下
     

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
      int nSize = mapStudent.size()
      for(int nIndex = 0; nIndex < nSize; nIndex++)
    {
      Cout<<mapStudent[nIndex]<<end;
    }
    }

    5. 数据的查找(包括判定这个关键字是否在map中出现)
    在这里我们将体会,map在数据插入时保证有序的好处。
    要判定一个数据(关键字)是否在map中出现的方法比较多,这里标题虽然是数据的查找,在这里将穿插着大量的map基本用法。
    这里给出三种数据查找方法
    第一种:用count函数来判定关键字是否出现,其缺点是无法定位数据出现位置,由于map的特性,一对一的映射关系,就决定了count函数的返回值只有两个,要么是0,要么是1,出现的情况,当然是返回1了
    第二种:用find函数来定位数据出现位置,它返回的一个迭代器,当数据出现时,它返回数据所在位置的迭代器,如果map中没有要查找的数据,它返回的迭代器等于end函数返回的迭代器,程序说明

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
      map<int, string>::iterator iter;
      iter = mapStudent.find(1);
    if(iter != mapStudent.end())
    {
      Cout<<”Find, the value is ”<<iter->second<<endl;
    }
    Else
    {
      Cout<<”Do not Find”<<endl;
    }
    }


    第三种:这个方法用来判定数据是否出现,是显得笨了点,但是,我打算在这里讲解
    Lower_bound函数用法,这个函数用来返回要查找关键字的下界(是一个迭代器)
    Upper_bound函数用法,这个函数用来返回要查找关键字的上界(是一个迭代器)
    例如:map中已经插入了1,2,3,4的话,如果lower_bound(2)的话,返回的2,而upper-bound(2)的话,返回的就是3
    Equal_range函数返回一个pair,pair里面第一个变量是Lower_bound返回的迭代器,pair里面第二个迭代器是Upper_bound返回的迭代器,如果这两个迭代器相等的话,则说明map中不出现这个关键字,程序说明

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent[1] = “student_one”;
      mapStudent[3] = “student_three”;
      mapStudent[5] = “student_five”;
      map<int, string>::iterator iter;
    iter = mapStudent.lower_bound(2);
    {
      //返回的是下界3的迭代器
      Cout<<iter->second<<endl;
    }
    iter = mapStudent.lower_bound(3);
    {
      //返回的是下界3的迭代器
      Cout<<iter->second<<endl;
    }
     
    iter = mapStudent.upper_bound(2);
    {
      //返回的是上界3的迭代器
      Cout<<iter->second<<endl;
    }
    iter = mapStudent.upper_bound(3);
    {
      //返回的是上界5的迭代器
      Cout<<iter->second<<endl;
    }
     
    Pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;
    mapPair = mapStudent.equal_range(2);
    if(mapPair.first == mapPair.second)
      {
      cout<<”Do not Find”<<endl;
    }
    Else
    {
    Cout<<”Find”<<endl;
    }
    mapPair = mapStudent.equal_range(3);
    if(mapPair.first == mapPair.second)
      {
      cout<<”Do not Find”<<endl;
    }
    Else
    {
    Cout<<”Find”<<endl;
    }
    }


    6. 数据的清空与判空
    清空map中的数据可以用clear()函数,判定map中是否有数据可以用empty()函数,它返回true则说明是空map
    7. 数据的删除
    这里要用到erase函数,它有三个重载了的函数,下面在例子中详细说明它们的用法

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
     
    //如果你要演示输出效果,请选择以下的一种,你看到的效果会比较好
      //如果要删除1,用迭代器删除
      map<int, string>::iterator iter;
      iter = mapStudent.find(1);
      mapStudent.erase(iter);
     
      //如果要删除1,用关键字删除
      Int n = mapStudent.erase(1);//如果删除了会返回1,否则返回0
     
      //用迭代器,成片的删除
      //一下代码把整个map清空
      mapStudent.earse(mapStudent.begin(), mapStudent.end());
      //成片删除要注意的是,也是STL的特性,删除区间是一个前闭后开的集合
     
      //自个加上遍历代码,打印输出吧
    }


    8. 其他一些函数用法
    这里有swap,key_comp,value_comp,get_allocator等函数,感觉到这些函数在编程用的不是很多,略过不表,有兴趣的话可以自个研究
    9. 排序
    这里要讲的是一点比较高深的用法了,排序问题,STL中默认是采用小于号来排序的,以上代码在排序上是不存在任何问题的,因为上面的关键字是int型,它本身支持小于号运算,在一些特殊情况,比如关键字是一个结构体,涉及到排序就会出现问题,因为它没有小于号操作,insert等函数在编译的时候过不去,下面给出两个方法解决这个问题
    第一种:小于号重载,程序举例

    #include <map>
    #include <string>
    Using namespace std;
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
    }StudentInfo, *PStudentInfo; //学生信息
     
    Int main()
    {
      //用学生信息映射分数
      Map<StudentInfo, int>mapStudent;
      StudentInfo studentInfo;
      studentInfo.nID = 1;
      studentInfo.strName = “student_one”;
      mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
      studentInfo.nID = 2;
      studentInfo.strName = “student_two”;
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
    }
    以上程序是无法编译通过的,只要重载小于号,就OK了,如下:
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
      Bool operator < (tagStudentInfo const& _A) const
      {
      //这个函数指定排序策略,按nID排序,如果nID相等的话,按strName排序
      If(nID < _A.nID) return true;
      If(nID == _A.nID) return strName.compare(_A.strName) < 0;
      Return false;
      }
    }StudentInfo, *PStudentInfo; //学生信息
    第二种:仿函数的应用,这个时候结构体中没有直接的小于号重载,程序说明
    #include <map>
    #include <string>
    Using namespace std;
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
    }StudentInfo, *PStudentInfo; //学生信息
     
    Classs sort
    {
      Public:
      Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const
      {
      If(_A.nID < _B.nID) return true;
      If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;
      Return false;
      }
    };
     
    Int main()
    {
      //用学生信息映射分数
      Map<StudentInfo, int, sort>mapStudent;
      StudentInfo studentInfo;
      studentInfo.nID = 1;
      studentInfo.strName = “student_one”;
      mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
      studentInfo.nID = 2;
      studentInfo.strName = “student_two”;
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
    }


    5. 数据的查找(包括判定这个关键字是否在map中出现)
    在这里我们将体会,map在数据插入时保证有序的好处。
    要判定一个数据(关键字)是否在map中出现的方法比较多,这里标题虽然是数据的查找,在这里将穿插着大量的map基本用法。
    这里给出三种数据查找方法
    第一种:用count函数来判定关键字是否出现,其缺点是无法定位数据出现位置,由于map的特性,一对一的映射关系,就决定了count函数的返回值只有两个,要么是0,要么是1,出现的情况,当然是返回1了
    第二种:用find函数来定位数据出现位置,它返回的一个迭代器,当数据出现时,它返回数据所在位置的迭代器,如果map中没有要查找的数据,它返回的迭代器等于end函数返回的迭代器,程序说明

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
      map<int, string>::iterator iter;
      iter = mapStudent.find(1);
    if(iter != mapStudent.end())
    {
      Cout<<”Find, the value is ”<<iter->second<<endl;
    }
    Else
    {
      Cout<<”Do not Find”<<endl;
    }
    }
    第三种:这个方法用来判定数据是否出现,是显得笨了点,但是,我打算在这里讲解
    Lower_bound函数用法,这个函数用来返回要查找关键字的下界(是一个迭代器)
    Upper_bound函数用法,这个函数用来返回要查找关键字的上界(是一个迭代器)
    例如:map中已经插入了1,2,3,4的话,如果lower_bound(2)的话,返回的2,而upper-bound(2)的话,返回的就是3
    Equal_range函数返回一个pair,pair里面第一个变量是Lower_bound返回的迭代器,pair里面第二个迭代器是Upper_bound返回的迭代器,如果这两个迭代器相等的话,则说明map中不出现这个关键字,程序说明
    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent[1] = “student_one”;
      mapStudent[3] = “student_three”;
      mapStudent[5] = “student_five”;
      map<int, string>::iterator iter;
    iter = mapStudent.lower_bound(2);
    {
      //返回的是下界3的迭代器
      Cout<<iter->second<<endl;
    }
    iter = mapStudent.lower_bound(3);
    {
      //返回的是下界3的迭代器
      Cout<<iter->second<<endl;
    }
     
    iter = mapStudent.upper_bound(2);
    {
      //返回的是上界3的迭代器
      Cout<<iter->second<<endl;
    }
    iter = mapStudent.upper_bound(3);
    {
      //返回的是上界5的迭代器
      Cout<<iter->second<<endl;
    }
     
    Pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;
    mapPair = mapStudent.equal_range(2);
    if(mapPair.first == mapPair.second)
      {
      cout<<”Do not Find”<<endl;
    }
    Else
    {
    Cout<<”Find”<<endl;
    }
    mapPair = mapStudent.equal_range(3);
    if(mapPair.first == mapPair.second)
      {
      cout<<”Do not Find”<<endl;
    }
    Else
    {
    Cout<<”Find”<<endl;
    }
    }


    6. 数据的清空与判空
    清空map中的数据可以用clear()函数,判定map中是否有数据可以用empty()函数,它返回true则说明是空map
    7. 数据的删除
    这里要用到erase函数,它有三个重载了的函数,下面在例子中详细说明它们的用法

    #include <map>
    #include <string>
    #include <iostream>
    Using namespace std;
    Int main()
    {
      Map<int, string> mapStudent;
      mapStudent.insert(pair<int, string>(1, “student_one”));
      mapStudent.insert(pair<int, string>(2, “student_two”));
      mapStudent.insert(pair<int, string>(3, “student_three”));
     
    //如果你要演示输出效果,请选择以下的一种,你看到的效果会比较好
      //如果要删除1,用迭代器删除
      map<int, string>::iterator iter;
      iter = mapStudent.find(1);
      mapStudent.erase(iter);
     
      //如果要删除1,用关键字删除
      Int n = mapStudent.erase(1);//如果删除了会返回1,否则返回0
     
      //用迭代器,成片的删除
      //一下代码把整个map清空
      mapStudent.earse(mapStudent.begin(), mapStudent.end());
      //成片删除要注意的是,也是STL的特性,删除区间是一个前闭后开的集合
     
      //自个加上遍历代码,打印输出吧
    }


    8. 其他一些函数用法
    这里有swap,key_comp,value_comp,get_allocator等函数,感觉到这些函数在编程用的不是很多,略过不表,有兴趣的话可以自个研究
    9. 排序
    这里要讲的是一点比较高深的用法了,排序问题,STL中默认是采用小于号来排序的,以上代码在排序上是不存在任何问题的,因为上面的关键字是int型,它本身支持小于号运算,在一些特殊情况,比如关键字是一个结构体,涉及到排序就会出现问题,因为它没有小于号操作,insert等函数在编译的时候过不去,下面给出两个方法解决这个问题
    第一种:小于号重载,程序举例

    #include <map>
    #include <string>
    Using namespace std;
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
    }StudentInfo, *PStudentInfo; //学生信息
     
    Int main()
    {
      //用学生信息映射分数
      Map<StudentInfo, int>mapStudent;
      StudentInfo studentInfo;
      studentInfo.nID = 1;
      studentInfo.strName = “student_one”;
      mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
      studentInfo.nID = 2;
      studentInfo.strName = “student_two”;
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
    }
    以上程序是无法编译通过的,只要重载小于号,就OK了,如下:
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
      Bool operator < (tagStudentInfo const& _A) const
      {
      //这个函数指定排序策略,按nID排序,如果nID相等的话,按strName排序
      If(nID < _A.nID) return true;
      If(nID == _A.nID) return strName.compare(_A.strName) < 0;
      Return false;
      }
    }StudentInfo, *PStudentInfo; //学生信息
    第二种:仿函数的应用,这个时候结构体中没有直接的小于号重载,程序说明
    #include <map>
    #include <string>
    Using namespace std;
    Typedef struct tagStudentInfo
    {
      Int nID;
      String strName;
    }StudentInfo, *PStudentInfo; //学生信息
     
    Classs sort
    {
      Public:
      Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const
      {
      If(_A.nID < _B.nID) return true;
      If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;
      Return false;
      }
    };
     
    Int main()
    {
      //用学生信息映射分数
      Map<StudentInfo, int, sort>mapStudent;
      StudentInfo studentInfo;
      studentInfo.nID = 1;
      studentInfo.strName = “student_one”;
      mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
      studentInfo.nID = 2;
      studentInfo.strName = “student_two”;
    mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
    }


    10. 另外
    由于STL是一个统一的整体,map的很多用法都和STL中其它的东西结合在一起,比如在排序上,这里默认用的是小于号,即less<>,如果要从大到小排序呢,这里涉及到的东西很多,在此无法一一加以说明。
    还要说明的是,map中由于它内部有序,由红黑树保证,因此很多函数执行的时间复杂度都是log2N的,如果用map函数可以实现的功能,而STL Algorithm也可以完成该功能,建议用map自带函数,效率高一些。
    下面说下,map在空间上的特性,否则,估计你用起来会有时候表现的比较郁闷,由于map的每个数据对应红黑树上的一个节点,这个节点在不保存你的数据时,是占用16个字节的,一个父节点指针,左右孩子指针,还有一个枚举值(标示红黑的,相当于平衡二叉树中的平衡因子)。

    展开全文
  • 1,map函数的基本用法 ** 1,map()函数是python的内置函数 2,map() 函数语法:map(function, iterable, …) function:函数 。 iterable: 一个或多个序列 3,第一个参数 function 以参数序列中的每一个元素...

    **

    1,map函数的基本用法

    **
    1,map()函数是python的内置函数
    2,map() 函数语法:map(function, iterable, …) function:函数 。 iterable: 一个或多个序列
    3,第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。

    4,python3中map()返回的是一个object,因为map()转变成了迭代器来节约空间,返回的是可迭代对象。
    5,如果需要list可以直接用list(……)来强制返回一个列表。
    6,Map的主要作用就是:并行!并行!并行!map函数和zip函数都是用来进行并行运算,迭代等。
    7,map() 的使用方法形如map(f(x),Itera),它有两个参数,第一个参数为某个函数,第二个为可迭代对象。

    def f(x):
        return x*x
    res = map(f, [1, 2, 3, 4, 5, 6, 7])
    
    print(res)
    print("map函数返回的对象类型是:", type(res))
    print("序列化输出结果为:", list(res))
    

    运行结果如下:

    <map object at 0x000001C989F0D080>
    map函数返回的对象类型是: <class 'map'>
    序列化输出结果为: [1, 4, 9, 16, 25, 36, 49]
    

    **

    2,自定义map()函数

    **

    list1 = [1, 2, 3, 4, 5, 6, 7, 8]
    
    
    def func(x):
        return x ** 2
    
    
    def my_map(func1, args):
        list2 = []
        for i in args:
            c = func1(i)
            list2.append(c)
        print(list2)
    
    my_map(func, list1)
    

    运行结果如下:

    [1, 4, 9, 16, 25, 36, 49, 64]
    
    展开全文
  • 常用函数之map函数

    千次阅读 2019-04-28 15:28:06
    map函数 map函数作用: 根据提供的函数对指定的序列做映射。通俗地讲就是以参数序列中的每个元素分别调用参数中的函数(func()),把每次调用后返回的结果保存到返回值中 map函数定义格式如下: map(func,*...

    map函数

    map函数作用: 根据提供的函数对指定的序列做映射。通俗地讲就是以参数序列中的每个元素分别调用参数中的函数(func()),把每次调用后返回的结果保存到返回值中

    map函数定义格式如下:

    map(func,*iterable)   ->map   object
    

    说明:
    第一个参数是函数的名称,第二个参数是迭代类型,它的返回结果是一个object类型

    代码演示:

    func = lambda x:x+2
    result = map(func,[1,2,3,4,5])
    print(list(result))
    

    输出结果如下:

    [3,4,5,6,7]
    

    注: 在上述例子中,定义了匿名函数并赋值给变量func,然后通过map()函数把序列中的每个元素取出来,作为参数调用func()函数,然后把结果放到result中。

    展开全文
  • python map函数和filter函数

    千次阅读 2020-06-29 18:02:04
    文章目录map函数filter函数 map函数 个人理解是对原来的序列进行操作,得到一个新的序列 list3 = [1, 2, 3, 4] list4 = map(lambda x: x*2, list3) print(list4) for i in list4: print(i, end=" ") print() list...
  • C++ map函数

    2020-02-11 16:34:01
    C++中的map函数 简单一般的map构造函数: map < string , int > mapstring; map < int , string > mapint; map < sring , char > mapstring; map < char , string > mapchar; map < ...
  • python中的map函数

    万次阅读 多人点赞 2019-07-11 16:11:29
    1 map()函数的简介以及语法: map是python内置函数,会根据提供的函数对指定的序列做映射。 map()函数的格式是: map(function,iterable,...) 第一个参数接受一个函数名,后面的参数接受一个或多个可迭代的...
  • python map函数

    2017-03-29 17:47:04
    python map函数
  • Python map函数

    2018-10-19 09:52:52
    map函数 按照我的理解,这就是封装的原理啊。你写好一个函数,给你一个接口,去调用。 上图自己去理解
  • 这篇文章主要介绍了Python函数的返回值、匿名函数lambda、filter函数、map函数、reduce函数用法,结合实例形式分析了Python函数的返回值、匿名函数lambda、filter函数、map函数、reduce函数相关功能、原理与使用技巧,...
  • 一、eval函数 说明: 可以将eval()括号里面的式子进行计算 ...map函数返回的是一个迭代器(在python中的3.x版本中) 可以利用for循环将其中数据输出来 例子: num = map(lambda x: x+1, [1,2,3]) for i in num:
  • map函数和lambda函数

    千次阅读 2018-05-06 16:11:15
    #map 函数 print('实例,获得两个列表上对应位置上的最小值') l1=[1,3,4,5] l2=[4,5,8,6] mins = map( min, l1, l2) #可以有效的避免for循环,比如比较列表中的相对应的最小值 print('mins: ',mins) #此时并不能打印...
  • python3 map函数和filter函数详解

    千次阅读 2020-02-18 21:59:28
    这篇文章主要介绍了python3 map函数和filter函数详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 map()函数可以对一个数据进行同等迭代操作。例如: def f...
  • 文章目录一、map函数的简介1、map函数的作用2、语法格式3、举例例1、例2、二、报错 一、map函数的简介 1、map函数的作用   对某个序列以给定的函数格式作映射。 2、语法格式   map(function,iterable)   ...
  • 1、map函数: map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。 1、当seq只有一个时,将函数func作用于这个seq的每个...
  • map函数改造for循环

    2018-05-02 09:58:24
    for循环函数 map函数
  • map函数的功能是根据提供的函数对指定序列做映射,就是对第二个参数的每一个值运行第一个参数所指定的函数 lambda是定义一个匿名函数 [crsusr@rws1270149 python_study]$ cat mypy02.py #!/usr/bin/python3.7 #...
  • python之map函数

    2019-06-21 13:53:00
    map函数会根据提供的函数对指定的序列做映射,放回的结果保存在迭代器中 func=lambda x:2*x-1 res=map(func,[1,2,3,4,5]) print(list(res)) func=lambda x,y,z:x+y+z res=map(func,[1,2,3],[4,5,6],[7,8,9]) for i...
  • python3的map函数

    千次阅读 2018-01-03 10:45:29
    python的map函数
  • map函数的用法

    千次阅读 2018-04-17 11:30:01
    map函数在python2和python3中稍有不同,python2直接返回一个列表,python3则返回一个map的可迭代对象一、python2的官方解释:map(...) map(function, sequence[, sequence, ...]) -&gt; list Return a list ...
  • C++map函数的用法

    万次阅读 多人点赞 2018-02-11 15:26:45
    map函数的一些整理 C++ map的基本操作和使用 Map是c++的一个标准容器,她提供了很好一对一的关系,在一些程序中建立一个map可以起到事半功倍的效果,总结了一些map基本简单实用的操作! 1、map简介 map是一类...
  • map函数的使用

    2017-05-19 14:25:08
    很想写这一篇,谈谈强大的map函数。怎样去使用它。
  • 高阶函数---map函数

    2018-03-12 19:17:16
    map函数: map(func, *iterables) 用函数对可迭代对象中的每一个元素作为参数计算出新的可迭代对象,当最短的一个可迭代对象完成迭代后迭代器生成结束 1).map函数 练习: # 1. 求1**2 + 2**2 + 3**2 + .... + 9...
  • python中map函数的简单使用

    千次阅读 2020-06-29 23:40:28
    Map函数的简单使用 map函数中的第一个参数是方法名,第二个参数是可以迭代的对象,第三个位置,第四个…也可以传参数,传进去的也是可迭代的对象,例如列表,字典,元组,字符串。这个函数会依次把可迭代对象中的每...
  • 1...lambda 函数相当于一个匿名函数,顾名思义就是不用取名字的函数,相当于现实中的匿名信。...2...map函数  map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 li...
  • python的map函数使用

    2017-07-30 13:39:03
    map函数可以用于在列方向上对列表进行处理map函数有如下3种使用情况:1.对可迭代函数中的每一个元素使用该方法,结果作为列表返回:e.g.def add20(number): number = number+20 return numberlist = [1,2,3] newlist ...
  • Python编程语言学习:python编程语言中重要函数讲解之map函数等简介、使用方法之详细攻略 目录 python编程语言中重要函数讲解之map函数等简介、使用方法之详细攻略 map函数 (1)、遍历所有字符串列表中最...
  • python3 map函数

    2017-10-07 11:36:28
    使用map函数可以直接输出列表 >>> list1 = [ 0, 1, 2, 3, 4, 5, 6 ] >>> list2 = map(lambda x:x*2,l1) 结果应为: >>> print(list2) [0,2,4,6,8,10,12] 但应用于python3 输出的结果并非如此,而是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,038
精华内容 15,215
关键字:

map函数