array_arraylist - CSDN
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。
收起全文
精华内容
参与话题
  • python中数组(numpy.array)的基本操作

    万次阅读 多人点赞 2018-10-21 11:23:44
    为什么要用numpy  Python中提供了list容器,可以当作数组使用。但列表中的元素可以是任何对象,... Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组(在TensorFlow里面偏向于矩阵理解),也...

     

    为什么要用numpy

        Python中提供了list容器,可以当作数组使用。但列表中的元素可以是任何对象,因此列表中保存的是对象的指针,这样一来,为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说,这种结构显然不够高效。
        Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组(在TensorFlow里面偏向于矩阵理解),也没有各种运算函数。因而不适合数值运算。
        NumPy的出现弥补了这些不足。

    (——摘自张若愚的《Python科学计算》)

    import numpy as np

     

    数组创建

    ## 常规创建方法
    a = np.array([2,3,4])
    b = np.array([2.0,3.0,4.0])
    c = np.array([[1.0,2.0],[3.0,4.0]])
    d = np.array([[1,2],[3,4]],dtype=complex) # 指定数据类型
    print a, a.dtype
    print b, b.dtype
    print c, c.dtype
    print d, d.dtype

     

    [2 3 4] int32
    [ 2.  3.  4.] float64
    [[ 1.  2.]
     [ 3.  4.]] float64
    [[ 1.+0.j  2.+0.j]
     [ 3.+0.j  4.+0.j]] complex128

     

    数组的常用函数
    print np.arange(0,7,1,dtype=np.int16) # 0为起点,间隔为1时可缺省(引起歧义下不可缺省)
    print np.ones((2,3,4),dtype=np.int16) # 2页,3行,4列,全1,指定数据类型
    print np.zeros((2,3,4)) # 2页,3行,4列,全0
    print np.empty((2,3)) #值取决于内存
    print np.arange(0,10,2) # 起点为0,不超过10,步长为2
    print np.linspace(-1,2,5) # 起点为-1,终点为2,取5个点
    print np.random.randint(0,3,(2,3)) # 大于等于0,小于3,2行3列的随机整数

     

    [0 1 2 3 4 5 6]
    [[[1 1 1 1]
      [1 1 1 1]
      [1 1 1 1]]

     [[1 1 1 1]
      [1 1 1 1]
      [1 1 1 1]]]
    [[[ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]]

     [[ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]
      [ 0.  0.  0.  0.]]]
    [[  1.39069238e-309   1.39069238e-309   1.39069238e-309]
     [  1.39069238e-309   1.39069238e-309   1.39069238e-309]]
    [0 2 4 6 8]
    [-1.   -0.25  0.5   1.25  2.  ]
    [[1 0 1]
     [0 1 0]]

     

     类型转换
    print float(1)
    print int(1.0)
    print bool(2)
    print float(True)

      

    1.0
    1
    True
    1.0

      

    数组输出

        从左到右,从上向下
        一维数组打印成行,二维数组打印成矩阵,三维数组打印成
    矩阵列表

    print np.arange(1,6,2)
    print np.arange(12).reshape(3,4) # 可以改变输出形状
    print np.arange(24).reshape(2,3,4)# 2页,3行,4页

      

    [1 3 5]
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]

     

    基本运算

    ## 元素级运算
    a = np.array([1,2,3,4])
    b = np.arange(4)
    print a, b
    print a-b
    print a*b
    print a**2
    print 2*np.sin(a)
    print a>2
    print np.exp(a) # 指数

       

    [1 2 3 4] [0 1 2 3]
    [1 1 1 1]
    [ 0  2  6 12]
    [ 1  4  9 16]
    [ 1.68294197  1.81859485  0.28224002 -1.51360499]
    [False False  True  True]
    [  2.71828183   7.3890561   20.08553692  54.59815003]

     

    ## 矩阵运算(二维数组)
    a = np.array([[1,2],[3,4]]) # 2行2列
    b = np.arange(6).reshape((2,-1)) # 2行3列
    print a,b
    print a.dot(b) # 2行3列

     

    [[1 2]
     [3 4]] [[0 1 2]
     [3 4 5]]
    [[ 6  9 12]
     [12 19 26]]

     

    ## 非数组运算,调用方法
    a = np.random.randint(0,5,(2,3))
    print a
    print a.sum(),a.sum(axis=1),a.sum(0) # axis用于指定运算轴(默认全部,可指定0或1)
    print a.min(),a.max(axis=1),a.mean(axis=1) # axis = 0: 按列计算,axis = 1: 按行计算
    print a.cumsum(1) # 按行计算累积和

     

    [[2 3 3]
     [0 2 1]]
    11 [8 3] [2 5 4]
    0 [3 2] [ 2.66666667  1.        ]
    [[2 5 8]
     [0 2 3]]

     

    索引,切片,迭代

    ## 一维数组
    a = np.arange(0,10,1)**2
    print a
    print a[0],a[2],a[-1],a[-2] # 索引从0开始,-1表示最后一个索引
    print a[2:5],a[-5:-1] # 包括起点,不包括终点
    a[-1] = 100; print a # 赋值
    a[1:4]=100; print a # 批量赋值
    a[:6:2] = -100; print a # 从开始到第6个索引,每隔一个元素(步长=2)赋值
    print a[: :-1];print a # 将a逆序输出,a本身未发生改变
    b = [np.sqrt(np.abs(i)) for i in a]; print b # 通过遍历赋值

      

    [ 0  1  4  9 16 25 36 49 64 81]
    0 4 81 64
    [ 4  9 16] [25 36 49 64]
    [  0   1   4   9  16  25  36  49  64 100]
    [  0 100 100 100  16  25  36  49  64 100]
    [-100  100 -100  100 -100   25   36   49   64  100]
    [ 100   64   49   36   25 -100  100 -100  100 -100]
    [-100  100 -100  100 -100   25   36   49   64  100]
    [10.0, 10.0, 10.0, 10.0, 10.0, 5.0, 6.0, 7.0, 8.0, 10.0]

      

    ## 多维数组
    a = np.arange(0,20).reshape((4,5))
    print a, a[2,3], a[:,1], a[1:4,2], a[1:3,:]
    print a[-1] # 相当于a[-1,:],即索引少于轴数时,确实的索引默认为整个切片

    b = np.arange(0,24).reshape((2,3,4))
    print b,b[1] # 相当于b[1,:,:] 和b[1,...]
    print '-------------------'
    for row in a:
        print row # 遍历以第一个轴为基础

     

    [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]
     [15 16 17 18 19]] 13 [ 1  6 11 16] [ 7 12 17] [[ 5  6  7  8  9]
     [10 11 12 13 14]]
    [15 16 17 18 19]
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]

     [[12 13 14 15]
     [16 17 18 19]
     [20 21 22 23]]
    -------------------
    [0 1 2 3 4]
    [5 6 7 8 9]
    [10 11 12 13 14]
    [15 16 17 18 19]

      

    形状操作

    a = np.floor(10*np.random.random((3,4)))
    print a, a.shape #输出a的形状
    print a.ravel() # 输出平坦化后的a(a本身不改变)
    a.shape = (6,2); print a # 改变a的形状
    print a.transpose() # 输出a的转置

     

    [[ 0.  4.  3.  2.]
     [ 1.  1.  3.  3.]
     [ 4.  4.  6.  5.]] (3, 4)
    [ 0.  4.  3.  2.  1.  1.  3.  3.  4.  4.  6.  5.]
    [[ 0.  4.]
     [ 3.  2.]
     [ 1.  1.]
     [ 3.  3.]
     [ 4.  4.]
     [ 6.  5.]]
    [[ 0.  3.  1.  3.  4.  6.]
     [ 4.  2.  1.  3.  4.  5.]]

     

    ## 补充:reshape和resize
    a = np.array([[1,2,3],[4,5,6]])
    b = a
    a.reshape((3,2))# 不改变数组本身的形状
    print a
    b.resize((3,2))# 改变数组本身形状
    print b

      

    [[1 2 3]
     [4 5 6]]
    [[1 2]
     [3 4]
     [5 6]]

    ---------------------

      在numpy模块中,我们经常会使用resize 和 reshape,在具体使用中,通常是使用resize改变数组的尺寸大小,使用reshape用来增加数组的维度。

    1.resize

    之前看到别人的博客说,resize没有返回值,其实这取决于你如何使用resize,resize有两种使用方式,一种是没有返回值的,直接对原始的数据进行修改,还有一种用法是有返回值的,所以不会修改原有的数组值。

    1.1有返回值,不对原始数据进行修改

        import numpy as np
        X=np.array([[1,2,3,4],
                      [5,6,7,8],
                      [9,10,11,12]])
         
        X_new=np.resize(X,(3,3)) # do not change the original X
        print("X:\n",X)  #original X
        print("X_new:\n",X_new) # new X
         
        >>
        X:
         [[ 1  2  3  4]
         [ 5  6  7  8]
         [ 9 10 11 12]]
        X_new:
         [[1 2 3]
         [4 5 6]
         [7 8 9]]

    1.2 无返回值,直接修改原始数组的大小

        import numpy as np
        X=np.array([[1,2,3,4],
                      [5,6,7,8],
                      [9,10,11,12]])
         
        X_2=X.resize((3,3))  #change the original X ,and do not return a value
        print("X:\n",X)  # change the original X
        print("X_2:\n",X_2) # return None
         

         
        X:
         [[1 2 3]
         [4 5 6]
         [7 8 9]]
        X_2:
         None


    2.reshape

    给数组一个新的形状而不改变其数据

        import numpy as np
        X=np.array([1,2,3,4,5,6,7,8])
         
        X_2=X.reshape((2,4)) #retuen a 2*4 2-dim array
        X_3=X.reshape((2,2,2)) # retuen a 2*2*2 3-dim array
         
        print("X:\n",X)
        print("X_2:\n",X_2)
        print("X_3:\n",X_3)
         
        >>
        X:
         [1 2 3 4 5 6 7 8]
        X_2:
         [[1 2 3 4]
         [5 6 7 8]]
        X_3:
         [[[1 2]
          [3 4]]
         
         [[5 6]
          [7 8]]]
    ---------------------
    作者:墨晓白
    原文:https://blog.csdn.net/qq_24193303/article/details/80965274
     

    展开全文
  • Array [] 数组

    千次阅读 2018-08-13 15:46:44
    Array 数组 数组是指一组数据的集合,(容器)数组中的每个数据称为元素。在Java中,数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引 用类),但同一个数组里只能存放类型相同的元素。长度不可变...

    java.util.Arrays类

    ※ Array 数组

    数组是指一组数据的集合,(容器)数组中的每个数据称为元素。在Java中,数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引
    用类),但同一个数组里只能存放类型相同的元素。长度不可变,构建时会有默认值(JVM)创建数组大致包括如下步骤:

    . 声明一个数组类型的引用变量,简称为数组变量;
    . 用new语句构造数组的实例。new语句为数组分配内存,并且为数组中的每个元素赋予默认值;
    . 初始化,即为数组的每个元素设置合适的初始值。

    声明/创建/初始化赋值
    基本数据类型的声明
    int[] n;
    int n[];
    引用类型的声明
    Student[] stuff; Student是类名,[]存的是地址值
    Student stuff[];

    本章的主要内容:

    . 数组的创建,包括基本类型数组的创建和类类型数组的创建;
    . 访问数组的元素和长度属性;
    . 创建一个数组的数组;

    我之前已经接触过数组了,就是主函数(main方法)中的参数:
    public static void main(String[] args){

    }

    一. 数组变量的声明;

    声明数组:
    1) 一个存放同一类型数据的集合
    a. 即可以是基本类型,也可以是对象类型;
    b. 数组中的每个数据为元素;
    2) 数组是一个对象,成员是数组长度和数组中的元素;
    3) 声明了一个数组变量并不是创建了一个对象;
    4) 声明数组的方式:

    int[] IArray 或者 int IArray[] 基本数据类型数组,数组中存放的是基本数据类型。
    Teacher[] tArray 或者 Teacher tArray[] 类类型数组,数组中存放的是Teacher类创建的若干个的对象。

    注意:1) 声明数组变量的时侯,不能指定数组的长度,以下声明方式是非法的。

             int x[1];
             int[2] x;
    

    二. 初始化

    初始化:自变量创建后首次赋值的过程;

    1)创建数组对象;

    数组对象和其他Java对象一样,也用new语句创建;

       int[] iArray = new int[2];
    

    构建数组:第二个[]必须加参数,表示数组存储元素个数

    new int[2]语句执行以下步骤:

    a. 在堆区中为数组分配内存空间,以上代码创建了一个包含2个元素的int数组
    b. 为数组中的每个元素赋予其数据类型的默认值。
    byte/short/int/long 0
    float 0.0f
    double 0.0d
    String null
    char ‘\u0000’
    boolean false
    c. 返回数组对象的引用

    在用new语句创建数组对象时,需要指定数组长度。数组长度表示数组中包含的元素数目。数组长度可以用具体的数值表示,也可以用
    变量表示。如:

       int[] x = new int[10];
       或
       int[] x={1,23,54};
       int[] x=new int[]{3,43,23};//先给默认值在覆盖
       或
       int size=10;
       int[] x = new int[size];
    

    数组的长度可以为0,此时数组中一个元素也没有。例如:

       int[] x = new int[0];
    

    对于Java类的程序入口方法main(String args[]),如果运行时这个类没有输入参数,那么main()方法的参数args并不是null, 而是一个长度为0的数组。例如:

       public class Sample {
           public static void main(String[] args) {
                System.out.println(args.length);           //打印0
           }
       }
    
      java.util.Arrays
      toString(n);方法
       System.out.print(x[0]);//获取x[0]地址
       System.out.print(Arrays.toString(x[0]));//获取x[0]中的值
      sort(n)//对数组排序
      n.length//获取数组长度
      binarySearch(n,2)//前提:先排序
    

    数组对象创建后,它的长度是固定的。数组对象的长度是无法改变的,但是数组变量可以改变所引用的数组对象。

       int[] x = new int[3];
       int[] y = x;
       x = new int[4];
    

    2)初始化数组对象;

    数组中的每个元素都有一个索引,或者称为下标。数组中的第一个元素的索引为0,第二个元素的索引为1, 依次类推。
    通过索引可以访问数组中的元素或者给数组中元素内容赋值。

    (1) 声明、创建、初始化分开:
    //声明
    int[] iArray;
    //创建
    iArray = new int[2];
    //初始化
    iArray[0] = 0;
    iArray[1] = 1;

    (2) 声明、创建的同时并初始化数组;

    int[] iArray = {0, 1};
    int[] iArray = new int[]{0, 1};
    Student sArray[] = new Student[] { new Student(“George”, “Male”, 20), new Student()};
    Student[] stArray = { new Student(), new Student()} ;

    注意:a.下面这些都是非法的数组初始化方式:
    int[] x = new int[5]{5,4,3,2,1}; //编译出错,创建数组对象的同时并初始化的时候就不能指定数组长度了;

                   int[] x;
                   x = {5,4,3,2,1};                           //{5,4,3,2,1}必须在声明数组变量的语句中使用,不能单独使用
    

    3)多维数组;

    二维数组:
    本质:一维数组里面的元素也是数组
    int[] n=new int[]{1,2,3,4};
    n[0]=1;
    int[][] n=new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    n[0]={1,2,3,4}
    n[0][0]=1;

    Java支持多维数组。假定某个宾馆有三层楼,第一层有4个房间,第二层有3个房间,第三层有5个房间。某一天客户人住宿情况如
    下图所示:

       第三层:           |    |Tom |Jerry|    |Rose|
       第二层:          |Mary|    |Kevin|
       第一层:          |Mike|Jane|Duke |    |
    

    可以用两维数组来存储各个房间的客人信息。

       String[][] room = new String[3][];
       room[0] = new Stirng[]{"Mike","Jane","Duke",null};
       room[1] = new String[]{"Mary",null,"kevin"};
       room[2] = new String[]{null,"Tom","Jerry",null,"Rose"}
    
       以上代码等价于:
    
       String[][] room = {
                            {"Mike","Jane","Duke",null},
                            {"Mary",null,"kevin"},
                            {null,"Tom","Jerry",null,"Rose"}
             };
    

    多维数组本质上是数组的数组,数组的元素内容还是数组;写一个类MultiArray.java来创造一个二维数组并输出其中元素

    4)数组的边界:

    (1).一个数组的下标从0开始,数组通过数组的对象引用变量的下标访问数组。数组中第一个元素的索引为0, 第二元素的索引为1,依次类推。如果一个数组长度是5,要访问最后一个数组元素可以通过下标4来访问,如果通过下标5访问,超出了数组的边界,在运行时会抛出ArrayIndexOutOfBoundsException。

    (2).通过调用数组的length方法可以获得一个数组的元素个数(数组长度)。所有Java数组都有一个length属性,表示数组的长度. 该属性只能读取,但是不能修改。

    以下修改数组的length属性,这是非法的。

          int[] x = new int[4];
          x.length = 10;            //编译出错,length属性不能被修改。
    

    注:a. 数组变量必须在指向一个数组对象之后,才能访问其元素。

    public class Sample {
                       private int[] x;
    
                       public static void main(String[] args) {
                              Sample s = new Sample();
                              System.out.println(s.x);            //打印null
                              System.out.println(s.x[0]);         //运行时抛出NullPointerException
                              System.out.println(s.x.length);      //运行时抛出NullPointerException
                       }
                  }
    

    b. 当数组的元素为引用类型时,数组中存放的是对象的引用,而不是对象本身;

    练习:(1) 求一组值的平均值:

                     public class ArrayAvgTest {
                          public double avg(int[] n) {
                               double result = 0.0;
                               for(int i=0;i<n.length;i++) {
                                      result += n[i];
                               }
                               result /= n.length;
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayAvgTest a = new ArrayAvgTest();
                               int[] a = {100,60,80,90,75,38};
                               System.out.println("Avg score: " + a.avg(a));
                          }
                     }          

    (2) 求一组值的最大值:

                     public class ArrayMaxTest {
                          public int max(int[] n) {
                               int result = n[0];
                               for(int i=1;i<n.length;i++) {
                                      if(result<n[i])
                                            result = n[i];
                               }
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayMaxTest a = new ArrayMaxTest();
                               int[] n = {100,60,80,90,75,38};
                               System.out.println("Max score: " + a.max(n));
                          }
                     } 
    

    (3) 数组内容排序
    详见算法,选择排序、插入排序、冒泡排序。
    (4)java.util.Arrays辅助类的使用。sort(int[] n)以及binarySearch(int[] n,int key)
    方法的使用。

    注意: a. 这二个方法均为static方法,可直接通过类名使用;
    b. binarySearch方法必须保证数组中的元素已经按照升序排列,这样才能得到正确的结果;

    import java.util.Arrays;
    
            public class ArraySortTest2 {
    
                public void print(int[] n) {
                    for(int i=0;i<n.length;i++)
                        System.out.print(n[i] + "\t");
    
                    System.out.println();
                }
    
                public static void main(String[] args) {
                    ArraySortTest2 s = new ArraySortTest2();
                    int[] n = {100,60,80,90,75,38};
                    Arrays.sort(n);
                    System.out.println(Arrays.binarySearch(n, 80));
                    s.print(n);
                    System.out.println(Arrays.binarySearch(n, 80));     
                }
            }

    (5) 从众多手机号码中抽取一个获奖手机号码

            public class ArrayRandomTest {
                public String getTel(String[] n) {
                    int index = (int)(Math.random()*n.length);
                    return n[index];
                }
    
                public static void main(String[] args) {
                    ArrayRandomTest a = new ArrayRandomTest();
                    String[] n = { "1318259016", "13564560540","13858687810","13999999999"};
                    System.out.println(a.getTel(n));
                }
            }

    (6)产生四位长度的验证码, 验证码内容为大小写字母或数字组成;

            public class ArrayValidateCodeTest {
    
                private char[] c;
    
                public ArrayValidateCodeTest() {
                    String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                    c = s.toCharArray();
                }
    
                public String getValidateCode() {
                    int i1 = (int)(Math.random()*c.length);
                    int i2 = (int)(Math.random()*c.length);
                    int i3 = (int)(Math.random()*c.length);
                    int i4 = (int)(Math.random()*c.length);
    
                    return ""+c[i1]+c[i2]+c[i3]+c[i4];
                }
    
                public static void main(String[] args) {
                    ArrayValidateCodeTest a = new ArrayValidateCodeTest();
                    System.out.println(a.getValidateCode());
                }
            }

    5)数组的拷贝:
    数组的长度一旦确定之后便不能调整,我们可以通过复制数组的内容变通实现改变数组长度。在System类中提供一个辅助的arraycopy方法提供复制数组内容的功能:

       System.arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)
    
    参数1,需要被复制的目标数组(原始数组)
    参数2,从这个数组的那个一个位置开始复制(原始数组起始位置)
    参数3,需要把数据复制到的另外的那一个新的数组对象(目标数组)
    参数4,复制到新数组里面哪个位置(从这个位置开始算)(目标数组开始追加数组的角标)
    参数5,复制的目标数组的长度(原始数组复制的长度)
    

    6) 可变参数 JDK1.5或以上
    之前的写法
    在方法中可以把可变参当做数组使用。
    可变参表示当前参数的类型可以接受0到多个

    public void test(int[] a){
    
        }
        main:
            int[] i = {1,2,3,4};
            a.test(i);
    
        可变参数写法
        public void test2(int... a){
    
        }
        main:
            int[] i = {1,2,3,4};
            test2(i);
            test2();
            test2(1,2,3,4);
            test2(1,2,3,4,5,6,7);
    

    可变参数前面可以加其他参数(可变参必须在最后,不能同时出现两个可变参)

        public static void test3(String msg,int... a){
    
        }
        main:
            int[] i = {1,2,3,4};
            String msg = "helo";
            test3(msg,i);
            test3(msg);
            test3(msg,1,2,3,4);
            test3(msg,1,2,3,4,5,s6,7);
    
        可变参数后面不能加任何参数 这样是编译不通过的
        public static void test4(int... a,String msg){
    
        }

    7) 格式化输出 JDK1.5或以上
    System.out.printf是JDK1.5之后加入的新的方法,可以给我们格式化输出内容

    常见用法例子:
    // 定义一些变量,用来格式化输出。
    double d = 345.678;
    String s = “你好!”;
    int i = 1234;
    // “%”表示进行格式化输出,”%”之后的内容为格式的定义。
    // “f”表示格式化输出浮点数。
    System.out.printf(“%f”, d); //345.678000
    System.out.println();
    // “9.2”中的9表示输出的长度,2表示小数点后的位数。 注意输出数字前面的空格
    System.out.printf(“%9.2f”, d);// 345.68
    System.out.println();
    // “+”表示输出的数带正负号。
    System.out.printf(“%+9.2f”, d);// +345.68
    System.out.println();
    // “-“表示输出的数左对齐(默认为右对齐)。
    System.out.printf(“%-9.4f”, d);//345.6780
    System.out.println();
    // “+-“表示输出的数带正负号且左对齐。
    System.out.printf(“%+-9.3f”, d);//+345.678
    System.out.println();
    // “d”表示输出十进制整数。
    System.out.printf(“%d”, i);//1234
    System.out.println();
    // “o”表示输出八进制整数。
    System.out.printf(“%o”, i);//2322
    System.out.println();
    // “x”表示输出十六进制整数。
    System.out.printf(“%x”, i);//4d2
    System.out.println();
    // “#x”表示输出带有十六进制标志的整数。
    System.out.printf(“%#x”, i);//0x4d2
    System.out.println();
    // “s”表示输出字符串。
    System.out.printf(“%s”, s);//你好!
    System.out.println();
    System.out.printf(“输出一个浮点数:%f,一个整数:%d,一个字符串:%s”, d, i, s);
    //输出一个浮点数:345.678000,一个整数:1234,一个字符串:你好!

    展开全文
  • numpy.array 函数简介

    万次阅读 2018-06-10 10:16:11
    import numpy as npnumpy.array 常用变量及参数dtype变量,用来存放数据类型, 创建数组时可以同时指定。shape变量, 存放数组的大小, 这人值是可变的, 只要确保无素个数不变的情况下可以任意修改。(-1为自动适配...

    import numpy as np

    numpy.array 常用变量及参数

    • dtype变量,用来存放数据类型, 创建数组时可以同时指定。
    • shape变量, 存放数组的大小, 这人值是可变的, 只要确保无素个数不变的情况下可以任意修改。(-1为自动适配, 保证个数不变)
    • reshape方法,创建一个改变了形状的数组,与原数组是内存共享的,即都指向同一块内存。 

    创建数组的方法

    [python] view plain copy
    1. np.array([[1234],[4567], [78910]], dtype=np.float)  
    2. np.arange(0,1,0.1#0到1之间步长为0.1的数组, 数组中不包含1  
    3. np.linspace(015# 开始:0, 结束1, 元素个数 5。 array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])  
    4. np.logspace(015# 开始:0, 结束1, 元素个数 5. array([ 10**0.  ,  10**0.25,  10**0.5 ,  10**0.75,  10**1.  ])  
    5.                      # 结果是 array([  1.        ,   1.77827941,   3.16227766,   5.62341325,  10.        ])  
    6.   
    7. s = 'abcdefg'  
    8. np.fromstring(s, dtype=np.int8)  
    9.   
    10. def func2(i, j):  
    11.     return (i+1) * (j+1)  
    12. np.fromfunction(func2, (9,9))  
    13.   
    14. np.ones((22))  
    15. np.zero((22))  
    16. np.eye(2)  
    17.   
    18. #创建二维数组:  
    19. np.arange(06010).reshape(-11) + np.arange(06)  


    数据读取

    通过下标范围获取数据: 与python list对象操作一致。 不同点是这方法获取的数组与原数组是内存共享的。

    通过整数序列获取新数组:例 x[[3,2,3,2] ], 产生新数组, 内存不共享
    使用布尔数组获取数据:例: x[np.array([True, False, True, False, False])] 或 x[x>0.5], 返回True对应的数字。
    代码示例:
    [python] view plain copy
    1. >>> x = np.arange(10)  
    2. >>> y = x[::-1]  
    3. >>> x  
    4. array([0123456789])  
    5. >>> y  
    6. array([9876543210])  
    7. >>> y[0] = 100  
    8. >>> x  
    9. array([  0,   1,   2,   3,   4,   5,   6,   7,   8100])  
    10. >>> y  
    11. array([100,   8,   7,   6,   5,   4,   3,   2,   1,   0])  
    12. >>> x[0] = 99  
    13. >>> x  
    14. array([ 99,   1,   2,   3,   4,   5,   6,   7,   8100])  
    15. >>> y  
    16. array([100,   8,   7,   6,   5,   4,   3,   2,   1,  99])  
    17. >>> y = x[1:6]  
    18. >>> y  
    19. array([12345])  
    20. >>> y[2] = 33  
    21. >>> y  
    22. array([ 1,  233,  4,  5])  
    23. >>> x  
    24. array([ 99,   1,   2,  33,   4,   5,   6,   7,   8100])  
    25. >>> x[[3,2,3,2]]  
    26. array([33,  233,  2])  
    27. >>> z = x[[3,2,3,2]]  
    28. >>> z  
    29. array([33,  233,  2])  
    30. >>> z[3] = 4  
    31. >>> z  
    32. array([33,  233,  4])  
    33. >>> x  
    34. array([ 99,   1,   2,  33,   4,   5,   6,   7,   8100])  
    35. >>> x[x>10]  
    36. array([ 99,  33100])  
    37. >>>   

    数组扩展
    np.vstack((a, b)):  增加行数, 把b数据追加到a的下面, 上下连接。
    np.hstack((a, b)): 增加列数,把a, b左右连接。
    [python] view plain copy
    1. >>> a = np.ones((3,3))  
    2. >>> b = np.eye(3)  
    3. >>> a  
    4. array([[ 1.,  1.,  1.],  
    5.        [ 1.,  1.,  1.],  
    6.        [ 1.,  1.,  1.]])  
    7. >>> b  
    8. array([[ 1.,  0.,  0.],  
    9.        [ 0.,  1.,  0.],  
    10.        [ 0.,  0.,  1.]])  
    11. >>> b *= 2  
    12. >>> b  
    13. array([[ 2.,  0.,  0.],  
    14.        [ 0.,  2.,  0.],  
    15.        [ 0.,  0.,  2.]])  
    16. >>> np.vstack((a, b))  
    17. array([[ 1.,  1.,  1.],  
    18.        [ 1.,  1.,  1.],  
    19.        [ 1.,  1.,  1.],  
    20.        [ 2.,  0.,  0.],  
    21.        [ 0.,  2.,  0.],  
    22.        [ 0.,  0.,  2.]])  
    23. >>>   
    24. >>> np.hstack((a, b))  
    25. array([[ 1.,  1.,  1.,  2.,  0.,  0.],  
    26.        [ 1.,  1.,  1.,  0.,  2.,  0.],  
    27.        [ 1.,  1.,  1.,  0.,  0.,  2.]])  

    ufunc运算

    ufunc是universal function的缩写,它是一种能对数组的每个元素进行操作的函数。NumPy内置的许多ufunc函数都是在C语言级别实现的,因此它们的计算速度非常快。

    [python] view plain copy
    1. np.sin(x, x)  
    2. np.add(a, b) ~ a+b  
    3. np.subtract(a, b) ~ a-b  
    4. np.multiply(a, b) ~ a*b  
    5. divide ~ a/b  
    6. floor divide  ~ a//b  
    7. negative ~ -a  
    8. power ~ a**b  
    9. remainder ~ a % b  


    注意:复杂运算时,中间步聚会有临时变量,这会拖慢运算速度。
    如:
    [python] view plain copy
    1. x = a*b + c  

    等价于
    [python] view plain copy
    1. t = a*b  
    2. x = t + c  
    3. del t  

    所以可手动优化

    [python] view plain copy
    1. x = a * b  
    2. x += c  

    二维数组转一维 

    [html] view plain copy
    1. >>> a  
    2. array([[ 1,  2,  3,  4],  
    3.        [ 4,  5,  6,  7],  
    4.        [ 7,  8,  9, 10]])  
    5. >>> a.ravel()  
    6. array([ 1,  2,  3,  4,  4,  5,  6,  7,  7,  8,  9, 10])  
    [html] view plain copy
    1. reshape函数可重新定义大小。  
    展开全文
  • Array

    2020-04-09 20:04:43
    存储具有一对一逻辑关系数据的存储顺序结构。 数组最大的优点:快速查询,最好应用于...bool Array<T>::add(const int index, const T& e) { if (index<0 || index>size)return false; //判断索...
    • 存储具有一对一逻辑关系数据的存储顺序结构
    • 数组最大的优点:快速查询,最好应用于索引有语义的情况。
      在这里插入图片描述

    插入元素

    在这里插入图片描述

    template<typename T>
    bool Array<T>::add(const int index, const T& e) 
    {
    	if (index<0 || index>size)return false;		//判断索引是否正确
    	if (size == capacity)resize(1.5 * capacity);	//判断空间是否足够,不够扩容为当前的2倍
    	for (int i = size - 1; i >= index; --i)		//从后向前循环
    	{
    		data[i + 1] = data[i];					//全部元素向后移一位
    	}
    	data[index] = e;							//插入元素	
    	++size;										//数组元素的个数+1
    	return true;
    }
    

    扩容与缩减

    在这里插入图片描述

    template<typename T>
    void Array<T>::resize(const int newcapacity)
    {
    	T* newdata = new T[newcapacity];	//创建新的传入大小数组空间
    	for (int i = 0; i < size; ++i)	//把原本的数组元素放入新的数组空间
    	{
    		newdata[i] = data[i];
    	}
    	data = newdata;		//把原本的数组指向新的数组
    	capacity = newcapacity;	//新的空间大小给原本的空间大小
    	newdata = nullptr;	//把新数组置为空
    	delete[] newdata;	//释放新数组
    }
    

    删除元素

    在这里插入图片描述

    template<typename T>
    T Array<T>::remove(const int index)	
    {
    	if (index<0 || index>size)return -1;	//判断索引是否正确
    	T ret = data[index];					//保存临时元素
    	for (int i = index + 1; i < size; ++i)	
    	{
    		data[i - 1] = data[i];				//从要插入的元素后一位所有元素向前移一位
    	}
    	--size;	//元素个数-1
    	if (size == capacity / 4 && capacity / 2 != 0)	//判断元素个数是否为数组容量的1/4并且数组空间不为0
    	{
    		resize(capacity / 2);	//调用resize传入当前容量的一半
    	}
    	return ret;		//返回被删除的元素
    }
    

    时间复杂度

    在这里插入图片描述

    均摊复杂度

    在这里插入图片描述
    在这里插入图片描述
      9次addLast操作,触发resize,总共进行了17次基本操作,平均每次addLast操作,进行2次基本操作。

      假设capacity = n,n+1次addLast,触发resize,总共进行2n+1次基本操作,平均每次addLast操作进行2次基本操作。

      这样均摊计算时间复杂度是O(1),同理removeLast操作,均摊复杂度也为O(1)。

    代码清单

    Array.h
    #pragma once
    #include<iostream>
    template<typename T>
    class Array
    {
    public:
    	//无参构造
    	Array() :size(0), capacity(10)	
    	{
    		data = new T[10];	//默认初始化10个空间
    	}
    	//有参构造
    	Array(int capacity) :size(0), capacity(capacity)
    	{
    		data = new T[capacity];
    	}
    	//返回元素个数
    	int getSize()const;
    	//返回数组容量
    	int getCapacity()const;
    	//返回第一个元素
    	T getFirst();
    	//返回最后一个元素
    	T getLast();
    	//判断是否为空
    	bool isEmpty()const;
    	//插入元素
    	bool add(const int index, const T& e);
    	//头插
    	bool addFirst(const T& e);
    	//尾插
    	bool addLast(const T& e);
    	//查找数组中是否存在该元素
    	bool contains(const T& e)const;
    	//查找数组中元素的索引,不存在返回-1
    	int find(const T& e)const; 
    	//删除索引元素,返回删除元素
    	T remove(const int index);
    	//删除头,返回头
    	T removeFirst();
    	//删除尾,返回尾
    	T removeLast();
    	//设置索引值
    	bool set(const int index, const T& e);
    	//获取索引值
    	T get(const int index)const;
    	//打印元素
    	void print()const;
    	//释放空间
    	~Array();
    private:
    	void resize(const int newcapacity);	//重新分配空间
    	T* data;
    	int size;	//数组大小
    	int capacity;	//数组容量
    };
    
    template<typename T>
    int Array<T>::getSize() const
    {
    	return size;	//返回数组长度	
    }
    
    template<typename T>
    int Array<T>::getCapacity() const
    {
    	return capacity;	//返回数组容量
    }
    
    template<typename T>
    inline T Array<T>::getFirst()
    {
    	return get(0);
    }
    
    template<typename T>
    inline T Array<T>::getLast()
    {
    	return get(size - 1);
    }
    
    template<typename T>
    bool Array<T>::isEmpty() const
    {
    	return size == 0;	//判断是否为空,
    }
    
    template<typename T>
    bool Array<T>::add(const int index, const T& e) 
    {
    	if (index<0 || index>size)return false;		//判断索引是否正确
    	if (size == capacity)resize(2 * capacity);	//判断空间是否足够,不够扩容为当前的2倍
    	for (int i = size - 1; i >= index; --i)		//从后向前循环
    	{
    		data[i + 1] = data[i];					//全部元素向后移一位
    	}
    	data[index] = e;							//插入元素	
    	++size;										//数组元素的个数+1
    	return true;
    }
    
    template<typename T>
    bool Array<T>::addFirst(const T& e) 
    {
    	return add(0, e);	//调用add从0号索引元素插入
    }
    
    template<typename T>
    bool Array<T>::addLast(const T& e)
    {
    	return add(size, e);	//调用add从size号索引元素插入
    }
    
    template<typename T>
    bool Array<T>::contains(const T& e) const
    {
    	for (int i = 0; i < size; ++i)	//遍历是否有查找的元素
    	{
    		if (data[i] == e)return true;	
    	}
    	return false;
    }
    
    template<typename T>
    int Array<T>::find(const T& e) const
    {
    	for (int i = 0; i < size; ++i)	//遍历是否有查找的元素,有返回索引,无返回-1
    	{
    		if (data[i] == e)return i;	
    	}
    	return -1;
    }
    
    template<typename T>
    T Array<T>::remove(const int index)	
    {
    	if (index<0 || index>size)return -1;	//判断索引是否正确
    	T ret = data[index];					//保存临时元素
    	for (int i = index + 1; i < size; ++i)	
    	{
    		data[i - 1] = data[i];				//从要插入的元素后一位所有元素向前移一位
    	}
    	--size;	//元素个数-1
    	if (size == capacity / 4 && capacity / 2 != 0)	//判断元素个数是否为数组容量的1/4并且数组空间不为0
    	{
    		resize(capacity / 2);	//调用resize传入当前容量的一半
    	}
    	return ret;		//返回被删除的元素
    }
    
    template<typename T>
    T Array<T>::removeFirst()		
    {
    	return remove(0);		//删除0号索引元素
    }
    
    template<typename T>
    T Array<T>::removeLast() 
    {
    	return remove(size - 1);	//删除size-1号索引元素
    }
    
    template<typename T>
    bool Array<T>::set(const int index, const T& e)
    {
    	if (index<0 || index>size)return false;	//判断索引元素是否正确
    	data[index] = e;						//设置索引的新元素
    	return true;
    }
    
    template<typename T>
    T Array<T>::get(const int index) const
    {
    	if (index<0 || index>size)return -1;	//判断索引元素是否正确
    	return data[index];						//返回索引元素
    }
    
    template<typename T>
    void Array<T>::print() const
    {
    	std::cout << "Array:size = " << size << "	Array:capacity = " << capacity << std::endl;
    	std::cout << "Array:data = " << "[";
    	for (int i = 0; i < size; ++i)
    	{
    		std::cout << data[i] << ",";
    	}
    	std::cout << "]" << std::endl;
    }
    
    template<typename T>
    Array<T>::~Array()
    {
    	delete[] data;	//释放空间
    	data = nullptr;
    }
    
    template<typename T>
    void Array<T>::resize(const int newcapacity)
    {
    	T* newdata = new T[newcapacity];	//创建新的传入大小数组空间
    	for (int i = 0; i < size; ++i)	//把原本的数组元素放入新的数组空间
    	{
    		newdata[i] = data[i];
    	}
    	data = newdata;		//把原本的数组指向新的数组
    	capacity = newcapacity;	//新的空间大小给原本的空间大小
    	newdata = nullptr;	//把新数组置为空
    	delete[] newdata;	//释放新数组
    }
    
    main.cpp
    #include"Array.h"
    using namespace std;
    
    int main()
    {
    	Array<int>* arr = new Array<int>(10);
    	for (int i = 0; i < 10; ++i)
    	{
    		arr->addLast(i);
    	}
    	arr->print();
    	cout << endl;
    	cout << "arr->add(1, 1)" << arr->add(1, 1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->addLast(0) " << arr->addLast(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->addFirst(0)" << arr->addFirst(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->contains(0)" << arr->contains(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->find(0)" << arr->find(0) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->get(1)" << arr->get(1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->set(0, 5)" << arr->set(0, 5) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getCapacity()" << arr->getCapacity() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getSize()" << arr->getSize() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->isEmpty()" << arr->isEmpty() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->remove(1)" << arr->remove(1) << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->removeFirst()" << arr->removeFirst() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->removeLast()" << arr->removeLast() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getFirst" << arr->getFirst() << endl;
    	arr->print();
    	cout << endl;
    	cout << "arr->getLast" << arr->getLast() << endl;
    	arr->print();
    
    	delete arr;
    	return 0;
    }
    
    展开全文
  • java中Array(数组)的用法

    万次阅读 2019-09-28 11:15:21
    8.Array(数组) 数组是作为对象来实现的。(really occupy the memopry,真实的占用内存 ) An array is a data structure that stores a collection of value of the same type.(数组是一个数据结构,它存储一堆...
  • Array和Arrays的区别

    千次阅读 2017-12-18 21:48:54
    Array的api如下: public final class Array extends Object The Array class provides static methods to dynamically create and access Java arrays. Array permits widening conversions to occur during a
  • numpy.array()

    千次阅读 2019-01-07 18:40:33
    前言: 相信大家在用python语言做机器学习的时候,经常会熟练的...因此,本篇针对array展开介绍,如有错误,欢迎指正。 np.array: 1.函数定义: 请点击这里,相信没有比它说明的更加清楚的了。 2.操作说明: 2...
  • Array[]数组(java)

    千次阅读 2019-06-14 20:24:51
    Array[]数组 1、概述 数组(Array), 是多个相同类型数据按一定顺序排列的集合, 并使用一个名字命名, 并通过编号的方式对这些数据进行统一管理。 2、注意点 数组本身是引用数据类型, 而数组中的元素可以是任何...
  • Tcl数组命令之array

    千次阅读 2019-05-14 22:54:04
    array
  • Array对象常用的方法

    千次阅读 2018-09-14 11:10:03
    Array对象常用的方法 不改变原数组的方法 1、concat() 语法:arrayObject.concat(arrayX,arrayX,......,arrayX)  输入值: 输入值可以是单个元素(多个元素),也可以是单个数组(多个数组) 功能:连接两个或...
  • Array.isArray()判断某个值是否为数组,返回布尔类型。举例如下: // 下面的函数调用都返回 true console.log(Array.isArray([])); console.log(Array.isArray([1])); console.log(Array.isArray(new Array()));...
  • numpy中array和asarray的区别

    万次阅读 多人点赞 2017-02-22 15:05:14
    array和asarray都可以将结构数据转化为ndarray,但是主要区别就是当数据源是ndarray时,array仍然会copy出一个副本,占用新的内存,但asarray不会。 举例说明: import numpy as np #example 1: data1=[[1,1,1],...
  • PHP 对象转数组 Object转array

    万次阅读 2013-02-04 15:14:49
    //PHP stdClass Object转array  ...function object_array($array) {   if(is_object($array)) {   $array = (array)$array;   } if(is_array($array)) {   foreach($array as $key=>$v
  • Pandas中把dataframe和np.array的相互转换

    万次阅读 多人点赞 2018-04-13 22:35:32
    网上找了半天 不是dataframe转化成array的就是array转化dataframe,所以这里给汇总一下,相互转换的python代如下:dataframe转化成arraydf=df.valuesarray转化成dataframeimport pandas as pd df = pd.DataFrame(df...
  • 问题截图如下 根据提示找到问题所在为 调用svc.predict()处出现问题 查看svc.predict的使用方法 print(help(svc.predict))参数的shape为[n_samples,n_features],例如(1,1118)而我传入的格式为 (1118,),...
  • setting an array element with a sequence

    万次阅读 2018-10-07 17:33:21
    setting an array element with a sequence   原因与解决: 矩阵的列没有对齐,一般情况用这个方法就行了:arrayname = np.concatenate(arrayname, axis=0) 。 arrayname是自己定义的矩阵名字...
  • 基本的排序算法

    万次阅读 2018-11-26 10:16:37
    1. 冒泡排序 ... public static int[] SmallBubbleSort(int[] array){ for(int i = 1; i &lt; array.length; i++){ for(int index = array.length - 1; index &gt;= i; index --){ i...
  • javascript 中文转拼音代码

    万次阅读 2012-02-16 23:14:32
    var array = new Array(1302); array[0] = "ā:阿啊呵腌吖锕"; array[1] = "á:啊呵嗄"; array[2] = "ǎ:啊呵"; array[3] = "à:啊呵"; array[4] = "a:阿啊呵"; array[5] = "āi:哀挨埃唉哎捱锿"; arra
  • numpy中np.array()与np.asarray的区别以及.tolist

    万次阅读 多人点赞 2018-09-07 16:35:15
    array和asarray都可以将结构数据转化为ndarray,但是主要区别就是当数据源是ndarray时,array仍然会copy出一个副本,占用新的内存,但asarray不会。 1.输入为列表时 a=[[1,2,3],[4,5,6],[7,8,9]] b=np.array(a) c...
  • python:IndexError: too many indices for array

    万次阅读 多人点赞 2018-01-24 22:56:50
    出现这样的情况你因为你矩阵的维度出现了冗余情况,比如你把一组数放入矩阵,矩阵默认的维度是2,但是你其实只有一列数,因此可以先用np.shape函数查看你的矩阵维度,是否出现了(n,)这样的情况。...
1 2 3 4 5 ... 20
收藏数 1,806,442
精华内容 722,576
关键字:

array