array 订阅
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。 展开全文
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。
信息
定    义
同类数据元素的集合
分    类
一维、二维(矩阵)、三维数组
中文名
数组
外文名
Array
数组产生来源
在C语言中, 数组 [2]  属于构造数据类型。一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。关于可变长数组(VLA)的问题:原来的C89标准中是不允许可变长数组出现的,但是在C99标准中,加入了对VLA的支持 [3]  ,但是支持的编译器不多,而且由于栈溢出的安全问题,没有太多的人敢用这个可变长数组,所以在C11标准中又把它规定为可选实现的功能了 [4]  。如果有过用其它语言编程的经历,那么想必会熟悉数组的概念。由于有了数组,可以用相同名字引用一系列变量,并用数字(索引)来识别它们。在许多场合,使用数组可以缩短和简化程序,因为可以利用索引值设计一个循环,高效处理多种情况。数组有上界和下界,数组的元素在上下界内是连续的。因为 Visual Basic对每一个索引值都分配空间,所以不要不切实际声明一个太大的数组。此处数组是程序中声明的变量数组。它们不同于控件数组,控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的;与控件数组不同的是,不能从一个数组的中部加载或卸载数组元素。一个数组中的所有元素具有相同的数据类型(在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样,比如在Visual Foxpro中的数组就并没这样的要求)。当然,当数据类型为 Variant 时,各个元素能够包含不同种类的数据(对象、字符串、数值等等)。可以声明任何基本数据类型的数组,包括用户自定义类型和对象变量。如果要用户输入的是一个数组,一般是用一个循环,但是在输入前也需要固定数组的大小。compact跟变长数组没有太大的关系,也应该用不到变长数组。因为一般的传数组到函数中就是传数组的地址和元素的个数的,那只是一个提示,不是要求。原型可以这样写(假设数组的元素是type):数组类型说明 在C语言中使用数组必须先进行类型说明。数组说明的一般形式为:类型说明符 数组名 [常量表达式],……; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的常量表达式表示数据元素的个数,也称为数组的长度。数组就是一次性定义相同数据类型的一组变量数组定义。说明整型数组a,有10个元素。若要表示第10个元素,则使用a[9]。第一个则是a[0]。说明实型数组b,有10个元素,实型数组c,有20个元素。说明字符数组ch,有20个元素。1.数组是相同数据类型的元素的集合。2.数组中的各元素的存储是有先后顺序的,它们在内存中按照这个先后顺序连续存放在一起。3.数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如,a[0]表示名字为a的数组中的第一个元素,a[1]代表数组a的第二个元素,以此类推。对于VB的数组,表示数组元素时应注意:1下标要紧跟在数组名后,而且用圆括号括起来(不能用其他括号)。2下标可以是常量,变量,或表达式,但其值必须是整数(如果是小数将四舍五入为整数)。3下标必须为一段连续的整数,其最小值成为下界,其最大值成为上界。不加说明时下界值默认为1。
收起全文
精华内容
下载资源
问答
  • C++ array使用方法详细介绍

    万次阅读 多人点赞 2019-11-04 11:20:36
    一个array——也就是容器类array的一份实体——模塑出一个static array。它包覆一个寻常的static C-style array 并提供一个STL容器接口。 通用格式:array<类型名, 元素个数> 数组名; 注意,因为长度固定,这里...

    更多关于STL的文章:STL专栏


    为了防止学习的过程中出现学后忘的情况,我将接触到的知识进行整理,作该笔记,由于本人水平有限,如果出现错误,还望赐正。

    介绍

    数组是固定大小的序列容器:它们包含按严格的线性顺序排列的特定数量的元素。一个array——也就是容器类array<>的一份实体——模塑出一个static array。它包覆一个寻常的static C-style array 并提供一个STL容器接口。

    通用格式:array<类型名, 元素个数> 数组名;

    注意,因为长度固定,这里的元素个数不能是变量。

    在内部,数组除了它所包含的元素之外不保留任何数据(甚至不保留它的大小,这是一个模板参数,在编译时固定)。就存储大小而言,它与使用该语言的括号语法([])声明的普通数组一样有效。这个类只是向它添加了一层成员和全局函数,它比寻常的数组安全,而且效率并没有因此变差,因此数组可以用作标准容器。

    与其他标准容器不同,数组具有固定的大小,并且不通过分配器管理其元素的分配:它们是封装固定大小的元素数组的聚合类型。因此,它们不能动态地展开或收缩。

    大小为零的数组是有效的,但是不应该取消对它们的引用(成员 front, back, 和 data)。

    数组容器的另一个独特的特性是它们可以被视为元组对象:array头文件重载get函数来访问数组的元素,就好像它是一个元组一样,还有专门的tuple_size和tuple_element类型。

    array并不支持(也就是不允许你指定)分配器(allocator)

    array成员函数

    函数功能
    begin(),end() ,cbegin(),cend()提供正向迭代器支持
    rbegin(),rend(),crbegin(),crend()提供反向迭代器支持
    size()返回数组大小
    max_size()返回数组最大大小(由于array为固定序列,该函数返回值与size()相同)
    empty()判断数组是否为空 (几乎没用)
    at(),operator[]获取数组元素
    front()返回数组第一个元素的引用
    back()返回数组最后一个元素的引用
    data()返回指向数组对象包含的数据的指针
    fill()用值填充数组
    swap()交换两个数组元素
    get(array)返回某一个数组元素的引用

    array会把元素复制到其内部的 static C-style array 中。这些元素总是拥有一个明确次序。因此 array 是一种有序集合。array 允许随机访问,也就是你可以在常量时间内直接访问任何元素, 前提是你得知道元素位置。 array 的迭代器属于随机访问迭代器,所以你可以对它运用任何STL算法。

    成员函数用法示例

    array用法及初始化

    template < class T, size_t N > class array;
    //T为所包含元素的类型,别名为成员类型value_type 。N为数组的大小,以元素数表示。

    在使用array前,首先要添加array这个头文件,即#include <array>

    注意:array<>是唯一一个无任何东西被指定为初值时,会被预初始化的容器。这意味着对于基础类型,初值可能不明确,而不是0,例如:下面定义一个有妖妖灵个int元素的数组arr:

         std::array<int,110> arr;
    

    上面定义的arr并未进行初始化。未初始化将会分配随机值,如图:

    在这里插入图片描述
    所以尽量不要定义未初始化的数组,否则访问数组元素,而该元素恰好未初始化时,可能出现意想不到的错误。

    array数组对象初始化与标准数组初始化一模一样,如:

        std::array<int,110> arr  { };//将数组所有元素初始化为0
    
        std::array<int,110> arr{1,2,3,4};//将数组前4个元素分别初始化为1,2,3,4,其余全部为0
    

    在这里插入图片描述
    另外由于没有提供针对初值而写的构造函数或assignment 操作符,因此“ 在array声明期间完成初始化”是使用初值列的唯一途径。基于这个原因,你无法使用小括号指明初值(此不同于其他容器类型)

    std::array<int,5> a({1,2,3,4,5})  //错误
    
    • fill()
      fiil() 函数可以用指定值给数组中所有元素赋值。

    fill()函数原型如下:

    void fill(const value_type & u); //value_type为数组元素类型;

    【例】

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,110> arr{1,2,4,5,6,7,8,9};
        arr.fill(3); //用3对数组所有元素赋值
        for(auto i:arr)
            cout<<i<<" ";
        cout<<endl;
        
        return 0;
    }
    

    输出结果为:

    3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

    array元素的获取

    特别注意!array,string,vector等容器的第一个元素下标为0!!!

    • array元素的获取可以使用下标[](与标准数组用法相同),以及STL容器特有的at()
      [] 与 at() 的区别在于,[]不会进行检查数字是否越界,而 at() 会进行检查(时间开销很少),如果越界则抛出 std::out_of_rang 异常。
      因此,除非确定访问没有越界,否则应该尽量使用更安全的 at() 。

    reference at(size_type n);
    const_reference at(size_type __n) const;

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,11> arr{1,2,3,4,5,6,7,8,9};
        arr.at(9) = arr.at(3) + arr.at(5);
        arr[10] = arr[1] + arr[8];
        cout<<arr.at(9)<<endl;
        cout<<arr[10]<<endl;
    
        //arr[11] = 6;越界访问,程序异常,但Qt Creator并未报错
        arr.at(11) = 6; //异常
        return 0;
    }
    

    程序运行结果为:

    10
    11

    terminate called after throwing an instance of ‘std::out_of_range’
    what(): array::at: __n (which is 11) >= _Nm (which is 11)

    • front() 和 back()
      front() 返回数组第一个元素的引用。
      back() 返回数组最后一个元素的引用。
    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,11> arr{1,2,3,4,5,6,7,8,9};
        arr.front() = 666;
        arr.back() = 666;
        for(auto i:arr)
            cout<<i<<" ";
        cout<<endl;
        return 0;
    }
    

    程序运行结果为:

    666 2 3 4 5 6 7 8 9 0 666

    (注:这两个函数极少使用)

    • data()
      返回指向数组对象中第一个元素的指针。
      该函数无参数。
    #include<iostream>
    #include<array>
    #include<cstring>
    using namespace std;
    
    int main()
    {   
        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    
        cout<< *arr.data()<<endl;
        cout<< *(arr.data()+6)<<endl;//获取元素
    
        const char* cstr = "Test string";
        std::array<char,12> charray;
        std::memcpy (charray.data(),cstr,charray.size());
    
        cout << charray.data() << endl;
    
    
        return 0;
    }
    
    

    程序运行结果为:

    1
    7
    Test string

    • size() 和 max_size()
      由于array在创建的时候必须明确指定大小,而且array为固定容器,因此max_size()与size()的返回值相同。
      通常使用 size() 函数。
      返回值类型为size_t 即无符号整数

    使用size()可以有效避免使用for遍历数组时,发生越界的情况。同时它也使得你在写程序的时候,不必去花心思记忆数组的大小。

        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    
        for(unsigned int i(0);i< arr.size();++i)
            cout<< arr[i] <<" ";
        cout<<endl;
    //程序运行结果为1 2 3 4 5 6 7 8 9 10
    
    • empty()
      该函数在array中为鸡肋函数。这是因为array在定义的时候已经指明了大小,不可能为空。除非你写出如此代码std::array<int,0> var;但这毫无意义。
      然而,对于其他元素可变或者元素可删除的容器来说,它们使用 empty() 时的机制是一样的,因此为它们提供了一个一致性的操作。

    Tuple接口

    array 提供 tuple 接口。因此可以使用表达式 tuple_size<>::value 取得元素个数,用 tuple_element<>::type 取得某特定元素的类型,用 get<>() 取得某特定元素。

    • get()
      get() 函数为非成员函数重载
      该函数返回array中指定元素的引用

    函数原型如下:

    template <size_t I, class T, size_t N> T& get (array<T,N>& arr) noexcept;
    template <size_t I, class T, size_t N> T&& get (array<T,N>&& arr) noexcept;
    template <size_t I, class T, size_t N> const T& get (const array<T,N>& arr) noexcept;
    //参数l为:元素在数组中的位置,第一个元素的位置为0 。
    //参数 T为:数组中包含的元素类型(通常从arr隐式获得)。
    //参数 N为:数组的大小,以元素数为单位(通常从arr隐式获得)。

    由于参数T,N可以从arr中隐式获得。因此在使用时一般不显式指定二者。
    【例】

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    
        //int a = std::get<6,int,10>(arr); 一般不这么写
    
        int a = std::get<6>(arr);
        cout<<a<<endl;
    
        std::get<5>(arr) = 666;
        for(auto i:arr)
            cout<<i<<" ";
        cout<<endl;
    
        return 0;
    }
    

    程序运行结果为:

    7
    1 2 3 4 5 666 7 8 9 10

    另外参数l必须是明确的数字,不能使用变量。如:

        int n = 3;
        std::get<n>(arr);//错误写法
    
    • tuple_size<>::value 和 tuple_element<>::type
      在array中用途不大,示例如下:
    #include <iostream>
    #include <array>
    #include <string>
    using namespace std;
    
    int main()
    {   
    
        std::array<string,5> arr = {"one","two","three","four","five"};;
        //返回元素个数
        cout<< std::tuple_size<decltype(arr)>::value <<endl;
        
        //获取第3个元素类型
        std::tuple_element<1,decltype(arr)>::type type = get<3>(arr);
        cout<< type <<endl;
    
        return 0;
    }
    

    程序运行结果为:

    5
    four

    array元素的修改

    array元素的修改与标准数组用法几乎相同。
    如:

        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
        arr[3] = 6;
        arr[2] = arr[0] + arr[1];
    

    同样也可以使用指针、引用对其进行修改。

    不同与标准数组的是:只要两个array类型的数组的数据类型和大小相同,就可以用 = 赋值。
    如:

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,3> arr_1 {1,2,3};
        std::array<int,3> arr_2 {4,5,6};
    
        arr_1 = arr_2; //用arr_2的元素覆盖arr_1的元素
    
        for(auto i:arr_1)
            cout<<i<<" ";
        cout<<endl;
    
        for(auto i:arr_2)
            cout<<i<<" ";
        cout<<endl;
    
        return 0;
    }
    

    输出结果为:

    4 5 6
    4 5 6

    • swap()
      交换两个array的值。注:这两个数组的大小,数据类型必须相同!
      无返回值,无参数。

    与标准库中的其他容器不同,交换两个数组容器是一种线性操作,涉及单独交换范围内的所有元素,这通常效率较低

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
        std::array<int,10> var{0,0,0,0,0,0,0,0,0,1};
    
        arr.swap(var);
    
        for(auto i:arr)
            cout<<i<<" ";
        cout<<endl;
    
        for(auto i:var)
            cout<<i<<" ";
        cout<<endl;
    
        return 0;
    }
    
    

    运行结果为:

    0 0 0 0 0 0 0 0 0 1
    1 2 3 4 5 6 7 8 9 10

    array迭代器

    名称功能
    begin( )返回指向数组第一个元素的迭代器。
    end()返回指向数组最后一个元素后紧跟的的理论元素的迭代器。
    cbegin()返回指向数组第一个元素的const类型迭代器。
    cend()返回指向数组最后一个元素后紧跟的的理论元素的const类型迭代器。
    rbegin()返回一个反向迭代器,该迭代器指向数组的最后一个元素(即它的反向开始)。
    rend()返回一个反向迭代器,该迭代器指向数组第一个元素之前的理论元素(该元素被视为反向元素)。
    crbegin()返回一个const类型反向迭代器,该迭代器指向数组的最后一个元素(即它的反向开始)。
    crend()返回一个const类型反向迭代器,该迭代器指向数组第一个元素之前的理论元素(该元素被视为反向元素)。

    下面为数组迭代器的简单用法:

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    
        array<int,10>::iterator it_beg = arr.begin();  //或者 auto it_beg = arr.begin();
        array<int,10>::reverse_iterator rit_beg = arr.rbegin(); //或者 auto rit_brg = arr.rbegin();
    
        for(;it_beg!=arr.end();it_beg++)
            cout<< *it_beg * 2<<" "; //二倍输出数组所有元素
        cout<<endl;
    
        for(;rit_beg != arr.rend();rit_beg++)
            cout<< *rit_beg << " "; //倒序输出数组元素
        cout<<endl;
    
        return 0;
    }
    

    输出结果为:

    2 4 6 8 10 12 14 16 18 20
    10 9 8 7 6 5 4 3 2 1

    在使用时最好用全局的 begin() 和 end() 函数从容器中获取迭代器,因为它们是通用的。
    如上述array<int,10>::iterator it_beg = arr.begin(); 可以写为array<int,10>::iterator it_beg = std::begin(arr);

    array元素的比较

    可以用任何比较运算符比较两个数组容器,只要它们有相同的大小,保存的是相同类型的元素,而且这种类型的元素还要支持比较运算符。示例如下:

    #include<iostream>
    #include<array>
    using namespace std;
    
    int main()
    {   
        std::array<int,3> arr_1 {1,2,3};
        std::array<int,3> arr_2 {1,2,3};
        std::array<int,3> arr_3 {1,3,2};
    
        if (arr_1 == arr_2)
            cout << "arr_1 = arr_2" << endl;
        if (arr_1 != arr_3)
            cout << "arr_1 != arr_3"<< endl;
        if (arr_1 < arr_3)
            cout << "arr_1 < arr_3"<< endl;
    
        return 0;
    }
    

    输出结果为:

    arr_1 = arr_2
    arr_1 != arr_3
    arr_1 < arr_3

    容器被逐元素地比较。对 ==,如果两个数组对应的元素都相等,会返回 true。对于 !=,两个数组中只要有一个元素不相等,就会返回 true。这也是字典中单词排序的根本方式,两个单词中相关联字母的不同决定了单词的顺序。

    展开全文
  • 1、np.mat() np.mat()函数用于将输入解释为矩阵。 np.mat(data, dtype=None) 不同于np.matrix,如果输入本身就已经是matrix或ndarray ,则np.asmatrix不会复制输入,而是...data:array_like。输入数据。 dtype:...

    欢迎关注WX公众号:【程序员管小亮】

    np.mat()函数用于将输入解释为矩阵。

    np.matrix()函数用于从类数组对象或数据字符串返回矩阵。

    np.array()函数用于创建一个数组。

    1、np.mat()

    np.mat(data, dtype=None)
    

    不同于np.matrix,如果输入本身就已经是matrix或ndarray ,则np.asmatrix不会复制输入,而是仅仅创建了一个新的引用。

    相当于np.matrix(data, copy=False)

    参数:

    • data:array_like。输入数据。

    • dtype:数据类型。输出矩阵的数据类型。

    返回:

    • mat:矩阵。数据被解释为矩阵。

    例子1:

    >>> x = np.array([[1, 2], [3, 4]])
    >>> m = np.asmatrix(x)
    >>> x[0,0] = 5
    >>> m
    matrix([[5, 2],
            [3, 4]])
    

    2、np.matrix()

    class numpy.matrix(data, dtype=None, copy=True)
    

    注意
    不再建议使用此类,即使对于线性代数也是如此。而是使用常规数组。该课程将来可能会被删除。

    矩阵是一种专用的二维阵列,通过操作保留其二维特性。

    它有一些特殊的运算符,如* (矩阵乘法)和 **(矩阵幂)。

    参数:

    • data : array_like或string。如果data是字符串,则将其解释为以逗号或空格分隔列的矩阵,以及分隔行的分号。

    • dtype : 数据类型。输出矩阵的数据类型。

    • copy : 布尔。如果data已经是ndarray,则此标志确定是复制数据(默认值)还是构造视图。

    例子2:

    >>> a = np.matrix('1 2; 3 4')
    >>> a
    matrix([[1, 2],
            [3, 4]])
    
    >>> np.matrix([[1, 2], [3, 4]])
    matrix([[1, 2],
            [3, 4]])
    

    3、np.array()

    numpy.array(object, 
    			dtype=None, 
    			copy=True, 
    			order='K', 
    			subok=False, 
    			ndmin=0)
    

    参数:

    • object : array_like
      数组,公开数组接口的任何对象,__array__方法返回数组的对象,或任何(嵌套)序列。

    • dtype : 数据类型,可选
      数组所需的数据类型。如果没有给出,那么类型将被确定为保持序列中的对象所需的最小类型。此参数只能用于“upcast”数组。对于向下转换,请使用.astype(t)方法。

    • copy : bool,可选
      如果为true(默认值),则复制对象。否则,只有当__array__返回副本,obj是嵌套序列,或者需要副本来满足任何其他要求(dtype,顺序等)时,才会进行复制。

    • order : {‘K’,‘A’,‘C’,‘F’},可选
      指定阵列的内存布局。如果object不是数组,则新创建的数组将按C顺序排列(行主要),除非指定了’F’,在这种情况下,它将采用Fortran顺序(专业列)。如果object是一个数组,则以下成立。

    orderno copycopy=True
    ‘K’unchangedF & C order preserved, otherwise most similar order
    ‘A’unchangedF order if input is F and not C, otherwise C order
    ‘C’C orderC order
    ‘F’F orderF order

    当copy=False出于其他原因而复制时,结果copy=True与对A的一些例外情况相同。默认顺序为“K”。

    • subok : bool,可选。如果为True,则子类将被传递,否则返回的数组将被强制为基类数组(默认)。

    • ndmin : int,可选。指定结果数组应具有的最小维数。为满足此要求,将根据需要预先设置形状。

    返回:

    • out : ndarray。满足指定要求的数组对象。

    例子3:

    >>>
    >>> np.array([1, 2, 3])
    array([1, 2, 3])
    

    上溯造型:

    >>>
    >>> np.array([1, 2, 3.0])
    array([ 1.,  2.,  3.])
    

    不止一个方面:

    >>>
    >>> np.array([[1, 2], [3, 4]])
    array([[1, 2],
           [3, 4]])
    

    最小尺寸2:

    >>>
    >>> np.array([1, 2, 3], ndmin=2)
    array([[1, 2, 3]])
    

    提供的类型:

    >>>
    >>> np.array([1, 2, 3], dtype=complex)
    array([ 1.+0.j,  2.+0.j,  3.+0.j])
    

    由多个元素组成的数据类型:

    >>>
    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
    >>> x['a']
    array([1, 3])
    ```py
    从子类创建数组:
    ```py
    >>>
    >>> np.array(np.mat('1 2; 3 4'))
    array([[1, 2],
           [3, 4]])
    >>>
    >>> np.array(np.mat('1 2; 3 4'), subok=True)
    matrix([[1, 2],
            [3, 4]])
    

    python课程推荐。
    在这里插入图片描述

    展开全文
  • JS Es6 Array方法

    千次阅读 2019-02-21 10:49:32
    JS array es6方法 定义数组 const array = [1, 2, 3]; 或者 const array = new Array(); array[0] = ‘1’; 建议尽量使用第一种形式定义数组,采用new的形式在大量的数组定义时,会比较耗时。 new关键字的使用,除了...

    JS array es6方法

    定义数组

    const array = [1, 2, 3];
    或者
    const array = new Array();
    array[0] = ‘1’;
    建议尽量使用第一种形式定义数组,采用new的形式在大量的数组定义时,会比较耗时。
    new关键字的使用,除了在需要实例化一个对象,或罕见的需要延时加载数据的情况外,你基本上不需要使用new关键字。在Javascript里分配大量的new变量地址是一项很慢的操作,为了效率起见,你应该始终使用对象符号。

    在另外一个搜索结果中,有提到这样的一个说法:“很简单,Array()是一个对象,[]是一个数据原型。使用new Array()系统每次都会新生成一个对象(浏览器每生成一个对象都会耗费资源去构造他的属性和方法),他的子集是[];个人推荐使用[],效率高。浏览器对于CPU很吃紧,所以很多时候要有技巧。比如数字转换成字符只要a=a+’’;就可以了,比用String效率高了很多。
    检测数组

    Array.isArray([]); // true
    Array.isArray(undefined); // false;

    或者
    array instanceof Array; // true 检测对象的原型链是否指向构造函数的prototype对象
    或者
    array.constructor === Array; // true

    终极大招:
    if (!Array.isArray) {
    Array.isArray = function(arg) {
    return Object.prototype.toString.call(arg) === ‘[object Array]’;
    };
    }

    注意:typeof []; // “object” 不可以用此方法检查!!!

    常用方法
    1. array.concat(array1, array2,…arrayN);
    合并多个数组,返回合并后的新数组,原数组没有变化。

    const array = [1,2].concat([‘a’, ‘b’], [‘name’]);
    // [1, 2, “a”, “b”, “name”]

    2. array.every(callback[, thisArg]);
    检测数组中的每一个元素是否都通过了callback测试,全部通过返回true,否则返回false。

    // callback定义如下: element:当前元素值;index:当前元素下标; array:当前数组
    function callback(element, index, array) {
    // callback函数必须返回true或者false告知every是否通过测试
    return true || false;
    }

    3. array.filter(callback[, thisArg]);
    返回一个新数组,包含通过callback函数测试的所有元素。

    // callback定义如下,三个参数: element:当前元素值;index:当前元素下标; array:当前数组
    function callback(element, index, array) {
    // callback函数必须返回true或者false,返回true保留该元素,false则不保留。
    return true || false;
    }
    const filtered = [1, 2, 3].filter(element => element > 1);
    // filtered: [2, 3];

    4. array.find(callback[, thisArg]);
    返回通过callback函数测试的第一个元素,否则返回undefined,callback函数定义同上。

    const finded = [1, 2, 3].find(element => element > 1);
    // finded: 2

    如果你需要找到一个元素的位置或者一个元素是否存在于数组中,使用Array.prototype.indexOf() 或 Array.prototype.includes()。
    5. array.findIndex(callback[, thisArg]);
    返回通过callback函数测试的第一个元素的索引,否则返回-1,callback函数定义同上。

    const findIndex = [1, 2, 3].findIndex(element => element > 1);
    // findIndex: 1

    6. array.includes(searchElement, fromIndex);
    includes() 方法用来判断一个数组是否包含一个指定的值,返回 true或 false。searchElement:要查找的元素;fromIndex:开始查找的索引位置。

    [1, 2, 3].includes(2, 2);
    // false

    7. array.indexOf(searchElement[, fromIndex = 0]);
    返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。searchElement:要查找的元素;fromIndex:开始查找的索引位置。

    [2, 9, 7, 8, 9].indexOf(9);
    // 1

    8. array.join(separator=’,’);
    将数组中的元素通过separator连接成字符串,并返回该字符串,separator默认为","。

    [1, 2, 3].join(’;’);
    // “1;2;3”

    9. array.map(callback[, thisArg]);
    返回一个新数组,新数组中的每个元素都是调用callback函数后返回的结果。注意:如果没有return值,则新数组会插入一个undefined值。
    array.map由于不具有过滤的功能,因此array调用map函数时,如果array中的数据并不是每一个都会return,则必须先filter,然后再map,即map调用时必须是对数组中的每一个元素都有效。

    const maped = [{name: ‘aa’, age: 18}, {name: ‘bb’, age: 20}].map(item => item.name + ‘c’);
    // maped: [‘aac’, ‘bbc’];

    10. array.pop() 与 array.shift();
    pop为从数组中删除最后一个元素,并返回最后一个元素的值,原数组的最后一个元素被删除。数组为空时返回undefined。

    [1, 2, 3].pop();
    // 3

    shift删除数组的第一个元素,并返回第一个元素,原数组的第一个元素被删除。数组为空返回undefined。

    const shifted = [‘one’, ‘two’, ‘three’].shift();
    // shifted: ‘one’

    11. array.push(element1, element2, …elementN) 与 array.unshift(element1, element2, …elementN);
    push是将一个或多个元素添加到数组的末尾,并返回新数组的长度; unshift将一个或多个元素添加到数组的开头,并返回新数组的长度。唯一的区别就是插入的位置不同。

    const arr = [1, 2, 3];
    const length = arr.push(4, 5);
    // arr: [1, 2, 3, 4, 5]; length: 5

    push和unshift方法具有通用性,通过call()或者apply()方法调用可以完成合并两个数组的操作。

    const vegetables = [‘parsnip’, ‘potato’];
    const moreVegs = [‘celery’, ‘beetroot’];

    // 将第二个数组融合进第一个数组
    // 相当于 vegetables.push(‘celery’, ‘beetroot’);
    Array.prototype.push.apply(vegetables, moreVegs);
    或者
    [].push.apply(vegetables, moreVegs);
    // vegetables: [‘parsnip’, ‘potato’, ‘celery’, ‘beetroot’]

    12. array.reduce(callback[, initialValue]);
    对数组中的每个元素(从左到右)执行callback函数累加,将其减少为单个值。

    const total = [0, 1, 2, 3].reduce((sum, value) => {
    return sum + value;
    }, 0);
    // total is 6

    const flattened = [[0, 1], [2, 3], [4, 5]].reduce((a, b) => {
    return a.concat(b);
    }, []);
    // flattened is [0, 1, 2, 3, 4, 5]

    // initialValue累加器初始值, callback函数定义:
    function callback(accumulator, currentValue, currentIndex, array) {
    }
    accumulator代表累加器的值,初始化时,如果initialValue有值,则accumulator初始化的值为initialValue,整个循环从第一个元素开始;initialValue无值,则accumulator初始化的
    值为数组第一个元素的值,currentValue为数组第二个元素的值,整个循环从第二个元素开始。initialValue的数据类型可以是任意类型,不需要跟原数组内的元素值类型一致。

    const newArray = [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].reduce((arr, element) => {
    if (element.age >= 2) {
    arr.push(element.name);
    }
    return arr; // 必须有return,因为return的返回值会被赋给新的累加器,否则累加器的值会为undefined。
    }, []);

    // newArray is [“bb”, “cc”];

    上面代码的同等写法:
    const newArray = [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].filter(element => element.age >= 2).map(item => item.name);
    // newArray is [“bb”, “cc”];

    对于reduce的特殊用法,其实类似于省略了一个变量初始化步骤,然后通过每次的callback的返回修改该变量,最后返回最终变量值的过程,类似于一个变量声明 + 一个forEach执行过程。
    const newArray = [];
    [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].forEach(item => {
    if (item.age >=2) {
    newArray.push(item.name);
    }
    });

    13. array.reverse();
    将数组中元素的位置颠倒。

    [‘one’, ‘two’, ‘three’].reverse();
    // [‘three’, ‘two’, ‘one’],原数组被翻转

    14. array.slice(begin, end)
    返回一个新数组,包含原数组从begin 到 end(不包含end)索引位置的所有元素。

    const newArray = [‘zero’, ‘one’, ‘two’, ‘three’].slice(1, 3);
    // newArray: [‘one’, ‘two’];

    15. array.some(callback[, thisArg]);
    判断数组中是否包含可以通过callback测试的元素,与every不同的是,这里只要某一个元素通过测试,即返回true。callback定义同上。

    [2, 5, 8, 1, 4].some(item => item > 6);
    // true

    16. array.sort([compareFunction]);
    对数组中的元素进行排序,compareFunction不存在时,元素按照转换为的字符串的诸个字符的Unicode位点进行排序,慎用!请使用时一定要加compareFunction函数,而且该排序是不稳定的。

    [1, 8, 5].sort((a, b) => {
    return a-b; // 从小到大排序
    });
    // [1, 5, 8]

    17. array.splice(start[, deleteCount, item1, item2, …]);
    通过删除现有元素和/或添加新元素来更改一个数组的内容。start:指定修改的开始位置;deleteCount:从 start位置开始要删除的元素个数;item…:要添加进数组的元素,从start 位置开始。
    返回值是由被删除的元素组成的一个数组。如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组。
    如果 deleteCount 大于start 之后的元素的总数,则从 start 后面的元素都将被删除(含第 start 位)。

    const myFish = [‘angel’, ‘clown’, ‘mandarin’, ‘sturgeon’];

    const deleted = myFish.splice(2, 0, ‘drum’); // 在索引为2的位置插入’drum’
    // myFish 变为 [“angel”, “clown”, “drum”, “mandarin”, “sturgeon”],deleted为[]

    小结

    push、 shift、 pop、 unshift、 reverse、 sort、 splice方法会对原来的数组进行修改,其他的数组操作方法只有返回值不同,对原数组都没有影响,即原数组不变。

    小结

    在看vue代码的时候,发现vue教程里面Array.apply(null, {length: 20})的用法,apply一直以为第二个参数只能是[]或者Arguments这样的类数组,了解了下发现{length: 20}也是类数组。 带有length属性的obj在apply函数里都被认定为类数组。可以理解为这里的{length: 20}会被默认为是一个数组了。下图的slice操作是只能在数组对象执行的操作,所以这里是一个数组。

    在这里插入图片描述

    看了下代码,apply生成的数组里面被初始化为了undefined,就是生成了长度为5的数组,而且数组的每个元素都被初始化为了undefined。
    Array(5)和new Array(5)调用效果是一致的。官网解释为:当把构造函数作为函数调用,不使用 new 运算符时,它的行为与使用 new 运算符调用它时的行为完全一样。 它们也生成了长度为5的数组,但是是个空数组,数组中的每个元素都没有初始化。

    为什么要这么写?
    map函数并不会遍历数组中没有初始化或者被delete的元素(有相同限制还有forEach, reduce方法)。
    Array.apply(null, { length: 5 }) 是用来初始化一个长度为5,每项的初始值都是undefined的数组。

    render (createElement) {
      return createElement('div',
      // 这里apply第一个对象为null, 当调用的函数不需要this对象时,可以传null,在es5之前浏览器会将null代表的this指向window。es5之后,浏览器不会再将this指向window。这里传null是因为Array构造函数会重新创建this,不需要传入this对象。
        Array.apply(null, { length: 20 }).map(function () {
         // 这里如果用Array(2)的形式,map的回调函数不会被执行
          return createElement('p', 'hi')
        })
      )
    }
    
    展开全文
  • 记录一下numpy.array()的详细用法,以及与np.asarray()和np.ndarray()的区别。 目录 1. Numpy.array()详解 1.1 函数形式 1.2 参数详解 1.3 具体用法 2.AsarrayArray辨析 2.1 object对象是普通迭代序列时 ...

    记录一下numpy.array()的详细用法,以及与np.asarray()和np.ndarray()的区别。

    目录

    1. Numpy.array()详解

    1.1 函数形式

    1.2 参数详解

    1.3 具体用法

    2. Asarray和Array辨析

    2.1 object对象是普通迭代序列时

    2.2 object对象是ndarray对象时

    3.Numpy.ndarray()


    1. Numpy.array()详解

    该函数的作用一言蔽之就是用来产生数组。

    1.1 函数形式

    numpy.array(object, 
        dtype=None, 
        copy=True, 
        order='K', 
        subok=False, 
        ndmin=0)

    1.2 参数详解

    object:必选参数,类型为array_like,可以有四种类型:数组,公开数组接口的任何对象,__array__方法返回数组的对象,或任何(嵌套)序列。np.array()的作用就是按照一定要求将object转换为数组。

    dtype:可选参数,用来表示数组元素的类型。如果没有给出,那么类型将被确定为保持序列中的对象所需的最小类型。注: This argument can only be used to ‘upcast’ the array. For downcasting, use the .astype(t) method.

    copy:可选参数,类型为bool值。如果为true(默认值),则复制对象。否则的话只有在以下三种情况下才会返回副本:(1).if __array__ returns a copy;(2). if obj is a nested sequence;(3). if a copy is needed to satisfy any of the other requirements (dtype, order, etc.)

    order:{‘K’, ‘A’, ‘C’, ‘F’},optional 。指定阵列的内存布局。该参数我至今还没有遇到过具体用法,这句话的意思就是我不会,故在此省略。

    subok:可选参数,类型为bool值。如果为True,则子类将被传递,否则返回的数组将被强制为基类数组(默认)。或者说,True:使用object的内部数据类型,False:使用object数组的数据类型。

    ndmin:可选参数,类型为int型。指定结果数组应具有的最小维数。

    返回对象

    out:输出ndarray,满足指定要求的数组对象。

    1.3 具体用法

    简单示例

    import numpy as np
    
    arr01 = np.array([1,2,3])
    print(arr01) #[1 2 3]
    print(type(arr01))  #<class 'numpy.ndarray'>
    print(arr01.dtype)  #int32
    
    #Upcasting
    arr02 = np.array([1.,2.,3.])
    print(arr02) #[1. 2. 3.]
    print(arr02.dtype)  #float64
    
    #More than one dimension:
    arr03 = np.array([[1,2],[3,4]])
    print(arr03)
    """
    [[1 2]
     [3 4]]
    """
    
    

     dtype参数使用示例

    import numpy as np
    
    #指定数组元素类型为复数类型
    DYX= np.array([1,2,3],dtype = complex)
    print(DYX) #[1.+0.j 2.+0.j 3.+0.j]
    print(DYX.dtype)  #complex128
    
    #由多个元素组成的数据类型:
    HXH = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i8')])
    print(HXH)  #[(1, 2) (3, 4)]
    #下面的输出有点神奇,我也只能记住规律了。
    print(HXH["a"]) #[1 3]
    print(HXH["b"])  #[2 4]
    print(HXH.dtype)  #[('a', '<i4'), ('b', '<i8')]
    print(HXH["a"].dtype) #int32
    print(HXH["b"].dtype) #int64
    
    TSL = np.array([(1,2,3),(4,5,6)],dtype=[("a","i"),("b","i"),("c","i")])
    print(TSL["a"]) #[1 4]
    print(TSL["a"].dtype)  #int32

    上述代码中,numpy的数据类型,可以参看: http://www.runoob.com/numpy/numpy-dtype.html

    subok参数使用示例

    import numpy as np
    
    DYX = np.array(np.mat('1 2; 3 4'))
    #没有显示的写出subok的值,但是默认为False
    print(DYX)
    #数组类型
    print(type(DYX))  #<class 'numpy.ndarray'>
    """
    [[1 2]
     [3 4]]
    """
    
    HXH = np.array(np.mat('1 2; 3 4'), subok=True)
    print(HXH)
    #矩阵类型
    print(type(HXH))  #<class 'numpy.matrixlib.defmatrix.matrix'>
    """
    [[1 2]
     [3 4]]
    """

    前文对subok的描述是这样的:“如果为True,则子类将被传递,否则返回的数组将被强制为基类数组(默认)”。

    在上文的代码中“np.mat('1 2; 3 4')”,就是子类,是矩阵类型。DYX = np.array(np.mat('1 2; 3 4'))中subok为False,返回的数组类型被强制为基类数组,所以DYX的类型是<class 'numpy.ndarray'>,是数组;HXH = np.array(np.mat('1 2; 3 4'), subok=True)中subok为True,子类被传递,所以HXH的类型是矩阵<class 'numpy.matrixlib.defmatrix.matrix'>。

    这就是区别所在。

    ndmin参数使用示例

    import numpy as np
    
    DYX = np.array([1,2,3],ndmin=0)
    print(DYX,DYX.shape) #[1 2 3] (3,)
    
    HXH = np.array([1,2,3],ndmin=1)
    print(HXH,HXH.shape) #[1 2 3] (3,)
    
    TSL = np.array([1,2,3],ndmin=2)
    print(TSL,TSL.shape) #[[1 2 3]] (1, 3)

    其他两个参数copy和order,我至今还没有遇到过,所以暂且不表。谁有介绍这两个参数用法的博客吗?

    2. Asarray和Array辨析

    Numpy.asaray的用法不再赘述,主要介绍一下二者的区别。

    2.1 object对象是普通迭代序列时

    import numpy as np
    
    data = [1,1,1]
    print(type(data)) #<class 'list'> 列表类型
    arr_ar = np.array(data)
    arr_as = np.asarray(data)
    
    #输出上没有区别
    print(arr_ar) #[1 1 1]
    print(arr_as) #[1 1 1]
    
    data[1]=2
    #改变原序列对arr_ar和arr_as没影响
    print(arr_ar) #[1 1 1]
    print(arr_as) #[1 1 1]
    
    #此时data是[1, 2, 1]
    #改变arr_ar和arr_as对原序列没有影响
    arr_ar[1]=3
    print(data) #[1, 2, 1]
    arr_as[1]=3
    print(data)  #[1, 2, 1]

    可见在参数对象是普通迭代序列时,asarray和array没有区别(在我的理解范围内)。

    2.2 object对象是ndarray对象时

    import numpy as np
    
    data = np.ones((3,))
    #print(type(data)) #<class 'numpy.ndarray'> 数组类型
    arr_ar = np.array(data)
    arr_as = np.asarray(data)
    
    print(arr_ar) #[1. 1. 1.]
    print(arr_as) #[1. 1. 1.]
    
    """
    这边区别就出来了。修改原始序列后,
    np.array()产生的数组不变,
    但是np.asarray()产生的数组发生了变化
    """
    data[1]=2
    print(arr_ar) #[1. 1. 1.]
    print(arr_as) #[1. 2. 1.]  !!!
    
    
    """
    这边也有区别,修改array产生的数组,不影响原始序列
    修改asarray产生的数组,会影响原始序列
    """
    #此时data=[1. 2. 1.]
    arr_ar[2]=3
    print(data)  #[1. 2. 1.]
    arr_as[2]=3
    print(data)  #[1. 2. 3.]
    

     

    我们总结一下:相同点:arrayasarray都可以将数组转化为ndarray对象。区别:当参数为一般数组时,两个函数结果相同;当参数本身就是ndarray类型时,array会新建一个ndarray对象,作为参数的副本,但是asarray不会新建,而是与参数共享同一个内存。重点就是这个共享内存。

    3.Numpy.ndarray()

    这是最近在一个项目里看到的用法,搜索了一下用法,只在stackoverflow看到了一个问题:What is the difference between ndarray and array in numpy?”。

    地址如下:https://stackoverflow.com/questions/15879315/what-is-the-difference-between-ndarray-and-array-in-numpy

    numpy.array只是一个创建ndarray的便利函数;它本身不是一个类。他讲到也可以使用numpy.ndarray创建一个数组,但这不是推荐的方法。 numpy.ndarray() 是一个类,而numpy.array() 是一个创建ndarray的方法/函数。

    在numpy docs中,如果你想从ndarray类创建一个数组,你可以用引用的2种方式来做:

    (1).using array(), zeros() or empty() methods: Arrays should be constructed using array, zeros or empty (refer to the See Also section below). The parameters given here refer to a low-level method (ndarray(…)) for instantiating an array.【1-使用array(), zeros()或empty()方法:数组应该使用array, zeros()或empty()构造。这里给出的参数引用用于实例化数组的低级方法(ndarray(…))。】

    (2).from ndarray class directly: There are two modes of creating an array using new: If buffer is None, then only shape, dtype, and order are used. If buffer is an object exposing the buffer interface, then all keywords are interpreted.【2-来自ndarray类:使用new创建数组有两种模式:如果buffer是None,则只使用shape,dtype和order。 如果buffer是公开buffer接口的对象,则解释所有关键字。】

    所以说老老实实用numpy.array()吧。

     

    本篇完结,行笔匆忙,如有错误,还望指出。

     

     

     

    展开全文
  • Array 函数

    千次阅读 2019-08-20 16:33:39
    array_combine 用两个数组的值作为新数组的键与值来新建一个数组 range 建立一个包含指定范围单元的数组  数组操作类函数 array_chunk 将一个数组分割成多个数组  array_column 返回输入数组中某个单一列的...
  • np.asarray()和np.array()区别

    千次阅读 多人点赞 2019-08-21 21:22:06
    如果输入是list,np.array() 和np.asarray()都可以理解为“深拷贝”,也就是修改a不影响b,c 如果输入是array, np.array()理解为“深拷贝”(修改a,不影响b的值)和np.asarray()理解为"浅拷贝"(修改a,影响c的值...
  • xarray数据结构之DataArray

    千次阅读 2020-02-07 20:47:42
    xarray数据结构之DataArray创建一个 DataArrayDataArray属性DataArray坐标(Coordinates) xarray.DataArray 是一个使用标签的多维数组,主要有以下几个关键属性: values:一个保存数组值的numpy.ndarray dims: 每个...
  • array_map与array_walk的用法与区别详解

    千次阅读 2018-11-05 15:44:19
    一、背景 &...网上百度一下array_map,然后发现了array_walk。这两个函数在某些情境下有异曲同工之妙,然后区别还是很大的。 二、关于array_map 1、文档 &amp;nbsp;&amp;nbsp;&amp;
  • 【C++】C++11的std::array的详细剖析

    万次阅读 多人点赞 2019-10-29 16:33:04
    当学习C++的时候,数组是最基本的结构之一,通常通过以下的方式来定义: ...在C++11中,引入了一种新的数组定义方式std::array。 std::array的特性 std::array是具有固定大小的数组。因此,它并不支持添加...
  • Python-Numpy中Array用法总结

    万次阅读 多人点赞 2018-10-14 19:45:12
    Numpy中array(数组) Numpy主要对象是齐次多维数组,由正整数元组索引,Numpy中维度称为轴(axis),数组的维数称为秩(rank)。 可以参考:Numpy快速入门 1.1 创建数组 常规方法创建数组 import numpy as np #一...
  • Scala之Array的方法

    万次阅读 多人点赞 2018-08-05 11:06:14
    Scala:Array(集合、序列) Scala开篇(目录) 数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示Java中的数组形式 T[]。 val numbers = Array(1, 2, 3, 4) //声明一个数组对象 val first =...
  • c++ array模板类使用

    万次阅读 多人点赞 2018-08-10 17:47:13
    1、array模板类的定义 (1)array模板类的声明 (2)容器属性 (3)array模板类的说明 (4)array模板类头文件 2、array模板类的使用 (1)Iterators (2)Capacity (3)Element access (4)Modifiers ...
  • Array对象常用的方法

    万次阅读 2018-04-01 09:35:10
    Array对象常用的方法 不改变原数组的方法 1、concat() 语法:arrayObject.concat(arrayX,arrayX,......,arrayX)  输入值: 输入值可以是单个元素(多个元素),也可以是单个数组(多个数组) 功能:连接两个或...
  • numpy对array索引

    万次阅读 2018-06-14 15:03:42
    numpy中array索引对numpy的array索引时总是容易出错,借此机会总结一下numpy中array最常用的索引方法1.单个元素的索引In [1]:#1.1.一维array,单个元素的索引使用整数 import numpy as np a = np.array([3, 5, 1, 2,...
  • [558]python3之数组(array)

    万次阅读 多人点赞 2019-03-13 18:41:22
    当我们需要1000万个浮点数的时候,数组(array)的效率要比列表(list)要高得多,因为数组在背后存的并不是float对象,而是数字的机器翻译,也就是字节表述。这一点和c语言中的数组一样。 再比如说,如果需要频繁对...
  • C++中的array容器

    千次阅读 2019-04-09 00:21:42
    c++ 11中提供了数组类Array(容器)该Array的引入引入为C风格的数组提供了更好的选择。array类相对于c类数组有以下的优点: 1. 数组类(Array class)知道自己的大小,而c风格的数组缺乏此属性。所以当传递给函数时...
  • Array 和 ArrayList 的区别

    千次阅读 2019-05-06 11:38:33
    Array 和 ArrayList 有何区别? Array 即数组,声明方式可以如下: int[] array = new int[3]; int array [] = new int[3]; int[] array = {1, 2, 3}; int[] array = new int[]{1, 2, 3}; 定义一个 Array 时...
  • 硬件-Array配置负载均衡

    千次阅读 2019-11-17 16:15:40
    Array设备 Array其实是类似于F5一样的硬件负载均衡,与传统软件负载Nginx类似,但是功能强大和并发量高 大致功能如下: 界面如下: SLB SLB负载均衡算法 非持久型 每一个新的连接都分配到均衡组内的不同的真实...
  • C++11中std::array的使用

    万次阅读 2017-05-30 13:57:56
    C++11中std::array的使用
  • numpy中array和asarray的区别

    千次阅读 2018-10-21 15:49:41
    numpy.asarray(a,dtype=None,order=None) 功能描述:将输入数据(列表的列表,元组的元组,元组的列表等)转换为矩阵形式 a:数组形式的输入数据,包括list,元组的list,元组,元组的元组,元组的list和ndarrays ...
  • array_filter()   该函数把输入数组中的每个键值传给回调函数。如果回调函数返回 true,则把输入数组中的当前键值返回结果数组中。数组键名保持不变。 $arr = ['a','b',1,2,3]; $new_arr = array_filter($arr,...
  • Hive中对array类型字段的处理

    万次阅读 多人点赞 2019-01-23 16:35:47
    现在有一张表,2个字段,字段A:id, 字段B:array类型: col_name data_type gameid int businesstype array select gameid, businesstype from kua.tablea where date=20190122 limit 5; +-----------+...
  • python中 array模块学习笔记

    千次阅读 2018-08-11 16:44:36
    array模块学习笔记 8.7. array — Efficient arrays of numeric values https://docs.python.org/3.5/library/array.html#module-array 一. array 模块就是数组,可以存放放一组相同类型的数字. Type ...
  • numpy 往array里添加一个元素

    千次阅读 2021-05-13 17:49:45
    首先这里p_arr为一个numpy的array,p_为一个元素 方法1: p_arr = np.concatenate((p_arr,[p_])) # 先将p_变成list形式进行拼接,注意输入为一个tuple: 方法2: p_arr = np.append(p_arr,p_) #直接向p_arr里...
  • Postgresql中array的常见用法

    千次阅读 2021-01-14 16:32:02
    Postgresql中array的常见用法 这些关于array的常见的脚本用法,可以满足日常需要: ---array --命名表 create table arraytest(inttype int,intshuzu int[],varshuzu varchar(32)[][]); --输入array值 INSERT INTO ...
  • Postgres array 数组类型详细使用

    千次阅读 2017-07-04 16:32:56
    //这篇文章主要参考了德哥的 文章,链接 : http://blog.163.com/digoal@126/blog/static/163877040201201275922529/德哥这篇文章...ARRAY类型包含几个重要的特征 维度 也就是几维数组, 不管怎么赋值, ARRAY最终必须
  • ArraySet 添加和删除元素分析

    千次阅读 2018-10-15 10:44:15
    本文的以我的视角分析ArraySet的add和remove过程,并做了简单的对比分析。 ##结构 ```ArraySet```实现了```Set```和```Collections```接口,故```add```和```remove```接口的使用方式相同,就...
  • Tcl数组命令之array

    千次阅读 2019-05-12 23:39:21
    array
  • ArrayObject的使用

    千次阅读 2018-06-09 15:31:25
    ArrayObject是将数组转换为数组对象。 代码示例 &amp;lt;?php //打印全部数组元素 $array =array('1'=&amp;gt;'one', '2'=&amp;gt;'two', '3'=&amp;gt;'three'); $arrayobject = new Array...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,483,125
精华内容 993,250
关键字:

array