精华内容
下载资源
问答
  • 整数数组 IntArray的实现,该在int数组内部进行操作。 该应为用户提供方便的方法来插入,删除和读取元素。
  • Numpy基础:数组和矢量计算 NumPy Basics: Arrays and Vectorized Computation 文章目录Numpy基础:数组和矢量计算NumPy Basics: Arrays and Vectorized Computation4.1 Numpy ndarry:一种多维数组对象(The NumPy...
  • 火山软件开发平台是易语言原创作者吴涛新作,是安卓快速开发中文编程之一,是提高安卓开发效率重要平台之一,鉴于目前中文教程很少,官网手册是非常好的教程之一,但是网站查看十分不方便,因此,本人整理出官方手册...
  • 数组操作方法大全

    2019-07-09 23:08:52
    话不多说,先上大纲,从目录来来回顾数组的各种操作方法,具体的使用方法在接下来会详细列出。 接下来是各个方法的具体使用方法: 数组:(ES6) callback[, thisArg] 其中: thisArg为callback函数的三个参数的...

    话不多说,先上大纲,从目录来来回顾数组的各种操作方法,具体的使用方法在接下来会详细列出。

    在这里插入图片描述


    接下来是各个方法的具体使用方法:
    数组:(ES6) callback[, thisArg] 其中: thisArg为callback函数的三个参数的总称---- value, index, currentArr

    数组遍历处理:

    1. array.forEach(callback[, thisArg])
    2. array.every(callback[, thisArg]);

    检测数组中的每一个元素是否全部通过了callback测试,全部通过返回true,否则返回false。>在这里插入图片描述

    1. array.some(callback[, thisArg]);

    判断数组中是否包含可以通过callback测试的元素,与every不同的是,这里只要某一个元素通过测试,即返回true。callback定义同上。在这里插入图片描述

    1. array.filter(callback[, thisArg]);

    返回一个新数组,包含通过callback函数测试的所有元素。在这里插入图片描述

    1. array.map(callback[, thisArg])
    1. 返回一个新数组,新数组中的每个元素都是调用callback函数后返回的结果。
    2. array.map由于不具有过滤的功能,因此array调用map函数时,如果array中的数据并不是每一个都会return,则必须先filter,然后再map,即map调用时必须是对数组中的每一个元素都有效。
    3. 注意:如果没有return值,则新数组会插入一个undefined值在这里插入图片描述
    1. array.reduce(callback[, initialValue]);
    1. 对数组中的每个元素(从左到右)执行callback函数累加,将其减少为单个值。
    2. function callback(accumulator, currentValue, currentIndex, array) { }
    3. accumulator代表累加器的值,初始化时,如果initialValue有值,则accumulator初始化的值为initialValue,整个循环从第一个元素开始;initialValue无值,则accumulator初始化的 值为数组第一个元素的值,currentValue为数组第二个元素的值,整个循环从第二个元素开始。initialValue的数据类型可以是任意类型,不需要跟原数组内的元素值类型一致。在这里插入图片描述

    数组元素查找:

    1. array.find(callback[, thisArg]);
    1. 返回通过callback函数测试的第一个元素,否则返回undefined。
    2. 注: 如果你需要找到一个元素的位置或者一个元素是否存在于数组中,使用 Array.prototype.indexOf()Array.prototype.includes()
      在这里插入图片描述
    1. array.findIndex(callback[, thisArg]);

    返回通过callback函数测试的第一个元素的索引,否则返回-1。在这里插入图片描述

    1. array.indexOf(searchElement[, fromIndex = 0])

    返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。searchElement:要查找的元素;fromIndex:开始查找的索引位置。
    在这里插入图片描述

    1. array.includes(searchElement, fromIndex)

    includes() 方法用来判断一个数组是否包含一个指定的值,返回 true或 false。searchElement:要查找的元素;fromIndex:开始查找的索引位置。
    在这里插入图片描述


    数组基本操作

    1. array.concat(array1, array2,…arrayN);

    合并多个数组,返回合并后的新数组,原数组没有变化。
    在这里插入图片描述

    1. array.join(separator=’,’)

    将数组中的元素通过separator连接成字符串,并返回该字符串,separator默认为","
    在这里插入图片描述

    1. array.pop() 与 array.shift()

    pop为从数组中删除最后一个元素,并返回最后一个元素的值,原数组的最后一个元素被删除。数组为空时返回undefined
    在这里插入图片描述
    shift删除数组的第一个元素,并返回第一个元素,原数组的第一个元素被删除。数组为空返回undefined。
    在这里插入图片描述

    1. array.push(element1, element2, …elementN) 与 array.unshift(element1, element2, …elementN)

    push是将一个或多个元素添加到数组的末尾,并返回新数组的长度; unshift将一个或多个元素添加到数组的开头,并返回新数组的长度。唯一的区别就是插入的位置不同。
    在这里插入图片描述
    push和unshift方法具有通用性,通过call()或者apply()方法调用可以完成合并两个数组的操作。
    在这里插入图片描述

    1. array.reverse()

    将数组中元素的位置颠倒
    在这里插入图片描述

    1. array.slice(begin, end)

    返回一个新数组,包含原数组从begin 到 end(不包含end)索引位置的所有元素。
    在这里插入图片描述

    1. array.sort([compareFunction])

    对数组中的元素进行排序,compareFunction不存在时,元素按照转换为的字符串的诸个字符的Unicode位点进行排序,慎用!请使用时一定要加compareFunction函数,而且该排序是不稳定的。
    在这里插入图片描述

    1. array.splice(start[, deleteCount, item1, item2, …])
    1. 通过删除现有元素和/或添加新元素来更改一个数组的内容。start:指定修改的开始位置;deleteCount:从 start位置开始要删除的元素个数;item…:要添加进数组的元素,从start 位置开始。
    2. 返回值是由被删除的元素组成的一个数组。如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组。如果 deleteCount 大于start 之后的元素的总数,则从 start 后面的元素都将被删除(含第 start 位)
      在这里插入图片描述
    1. arr.fill()
    1. [‘a’, ‘b’, ‘c’].fill(7)
      // [7, 7, 7]
    2. new Array(3).fill(7)
      // [7, 7, 7]
    3. fill方法还可以接受第二个和第三个参数,用于指定填充的起始位置和结束位置。
      [‘a’, ‘b’, ‘c’].fill(7, 1, 2)
      // [‘a’, 7, ‘c’]
    4. 填充的类型为对象,那么被赋值的是同一个内存地址的对象,而不是深拷贝对象
      let arr = new Array(3).fill({name: “Mike”});
      arr[0].name = “Ben”;
      arr
      // [{name: “Ben”}, {name: “Ben”}, {name: “Ben”}]
      let arr = new Array(3).fill([]);
      arr[0].push(5);
      arr
      // [[5], [5], [5]]
    展开全文
  • 通用函数:快速的逐元素数组函数 通用函数,也可以称为ufunc,是一种在 ndarray数据中进行逐元素操作的函数。某些简单函数接收一个或多个标量数值,并产生一个或多个标量结果,而通用函数就是对这些简单函数的...

                                      通用函数:快速的逐元素数组函数

     

    通用函数,也可以称为 ufunc,是一种在 ndarray 数据中进行逐元素操作的函数。某些简单函数接收一个或多个标量数值,并产生一个或多个标量结果,而通用函数就是对这些简单函数的向量化封装。

    一、一元通用函数:

    函数名 描述
    abs、fabs 逐元素地计算整数、浮点数或复数的绝对值
    sqrt 计算每个元素的平方根(与 arr ** 0.5 相等)
    square 计算每个元素的平方(与 arr ** 2 相等)
    exp 计算每个元素的自然指数值 e^{x}
    log、log10、log2、log1p 分别对应:自然对数(e为底)、对数10为底、对数2为底、log(1+x)
    sign 计算每个元素的符号值:1(正数)、0(0)、-1(复数)
    ceil 计算每个元素的最高整数值(即大于等于给定数值的最小整数)
    floor 计算每个元素的最小整数值(即小于等于给定元素的
    展开全文
  • 无法创建t的通用数组 在这篇文章中,我们将介绍一篇全面的文章,其中介绍了创建通用数组的问题。 Java编程语言于2004年9月在Java 5.0“ Tiger”发行版中添加了泛型。 泛型或类型参数化系统在提供类型安全性的同时...

    无法创建t的通用数组

    在这篇文章中,我们将介绍一篇全面的文章,其中介绍了创建通用数组的问题。 Java编程语言于2004年9月在Java 5.0“ Tiger”发行版中添加了泛型。 泛型或类型参数化系统在提供类型安全性的同时扩展了Java现有的类型系统。

    1.简介

    Java具有Collections Framework,它提供了用于Java软件开发的通用数据结构库。 集合框架缺少一种数据结构-数组。 但是,Java Collections Framework具有类型化参数化ArrayList.java和Vector.java数据结构。 两种数据结构都使用一维动态数组,该数组使用java.lang.Object的基础数组。

    Java提供了一个内置数组,该内置数组是自1995年以来的Java 1.0以来语言规范中所包含的对象。作为对象,内置数组在Java代码中声明并实例化为特定类型。 内置数组是对象的容器,对象的数量和长度是固定的,可能是多个维度。

    但是,使用泛型的编译时类型安全性尚未完全实现。 特别是内置数组对象。

    2.通用数组

    问题是当泛型与Java中的内置数组实体一起使用时。 考虑下面的Java类TestArray1.java,它在单个泛型类型参数E周围声明了两个泛型数组。Java类源代码为:

    class TestArray1 {
      public E[] array = new E[10];
    }//end class TestArray1

    TestArray1.java的源代码仅是声明性的,不使用数组。 编写了通用数组的两个用例:一个用于通用数组作为类属性,另一个用于在类的静态(即非实例)方法中使用通用数组。

    2.1编译时的一般错误

    编译时,编译器报告以下错误:

    Error: TestArray1.java.                                                             
          Line 3 At 22: generic array creation                                            
            public E[] array = new E[10];                                                 
                               ^

    报告了一种错误:通用数组创建。 此错误直接对应于通用数组的用例。

    协方差

    在Java中,数组是协变的,或对特定类型使用通用的类型专用化,例如对集合的集合。 但是,通用类型参数不是协变的。 Goetz解释说:“ Collections类使用一个丑陋的技巧来解决此问题……” [Goet 2019]

    因此,要将内置数组与Java泛型或泛型类型参数E一起使用,该数组必须为java.lang.Object类型,这是Java中的超大型类型。 一切都是一个java.lang.Object,这是丑陋的把戏。

    对象数组

    然而,使用对象数组的缺点是泛型必须将数据结构或变量绑定到特定类型。 对象类型的数据结构可以混合和匹配任何类型,并且需要类型转换才能转换为原始类型。 在这种情况下,Java中的泛型没有用处-这是核心问题。

    问题的解决方案或答案很简单-一个通用的Java数组类。 这样的类不在Java集合框架中,因此可以创建它。

    3. Java数组类

    Java Array类类似于Java集合框架中的其他数据结构,它是一个数据结构。 最初编写的实现是为了简单起见,并且不实现任何特定的接口或扩展任何超类。 目标是获得功能和有用的数组作为要构建的Array.java类。 通用类型参数Array.java类的框架为:

    class Array {
        Array(final int... dim);
        void init(final E elem);                                                             
        void init(final E[] elem);
        E get(final int...idx);
        void add(final E elem, final int... idx);					      	             
      }

    本质上,您可以构造任意级别的数组,然后构造任意大小的维度

    然后,该数组具有方法init()来将数组初始化为默认值或前哨初始值。 最后,数组具有两种主要方法,一种是在数组中的特定位置添加一个元素,另一个添加一个元素。 实例化或创建,初始化整个数组以及访问元素的基本功能。

    3.1数组类属性

    Java数组类具有几个属性,这些属性定义Array.java类的实例。 通用类型参数Array.java类的属性为:

    class Array {
        int size;                                                                             
        int dim[];                                                                            
        int rank;	                                                                             
        Object data[];                                                                    
        E elem;                                                                           
      }

    Array.java类属性是作为对象的内置数组的数据,该数组的边界,例如大小,等级,尺寸。 最后,还有一个元素,即初始化元素。

    3.2使用Varargs的等级和维度

    Java编程语言在2004年9月发行的Java 5.0“ Tiger”中添加了变量号或参数或自变量,命名为Java变量自变量,或更简单地说是varargs。此特殊功能允许构造函数或方法采用不同数量的参数,因此泛化参数,而不必仅仅为参数数量而复制构造函数或方法。

    Array类的一般化使用此特定的Java功能:varargs,或用于创建和访问Array.java类中的元素的变量参数。 这允许任何等级(维数),也允许任何非负整数的任何数字维。

    Varargs还允许等级为一般等级,因此Array.java类的等级(至少在理论上……)没有上限。 因此,可变参数允许在定义和使用通用Array.java类时进行整体概括。

    使用Varargs的构造函数

    Array.java构造函数的源代码说明了如何使用varargs作为维,以使用Array.java类创建通用数组对象。 等级和维度是通用的,因此任何维度范围的数组都可以排名。 Array.java构造函数的源代码为:

    Array(final int... dims) {                                                           
        this.rank = dims.length;                                                           
        this.dim  = new int[rank];                                                         
        int size  = 1;                                                                     
      
        //compute size of 1-dim internal array                                             
        for (int x = 0; x < dims.length; x++) {                                             
          size = size * dims[x];                                                           
          dim[x] = dims[x];                                                                 
        }//end for                                                                                                                                                      
      
        //create internal "flat" array                                                                                                            
        this.data = new Object[size];                                                  
        this.size = size;                                                                   
      }//end constructor

    varargs是作为基本int传递的可变参数,它们是变量dims中的整数数组。 根据暗淡程度,可以计算和创建数组边界的尺寸以及整个内部“平面”数组。 如果没有可变参数,则需要针对每个维度的不同维度的构造函数。 由于有限数量的构造函数用于等级,所以Array.java通用数组类将受到限制,而对于varargs而言则不那么普遍。

    带Varargs的访问器

    通过get和set方法访问通用数组中的元素。 这些是访问或访问方法。 与属性getter和setter方法不同,对于通用数组类,维度索引指定元素。

    使用varargs,可以概括访问任何等级或维度的访问方法。 对照通用数组的边界和等级检查维度索引以进行访问。

    读取访问者获取

    getter方法是读取访问器,它从数组读取或复制一个值。 Array.java的get访问器方法的源代码是:

    E get(final int... idx) {                                                            
        return (E) this.data[this.getIndex(idx)];                                      
      }//end get

    写访问器集

    setter方法是写访问器,它将值写入或复制到数组中。 Array.java set访问器方法的源代码是:

    void set(final E elem, final int... idx) {                                           
        this.data[this.getIndex(idx)] = elem;                                          
      }//end set

    为简单起见,辅助方法getIndex()进行了计算单个维度索引并检查数组索引边界的实际“繁重工作”。

    辅助方法

    在通用Array.java类中,三个辅助方法或辅助方法进行了实际处理。 一种方法,getIndex()从多个索引维度计算单个索引,其他两种方法isValidDim()和isValidIndex()验证所计算的索引或给定的索引没有超出数组的边界。 辅助方法的接口源代码为:

    class Array {
        int getIndex(final int... idx);
        boolean isValidDim(final int... idx);						       
        boolean isValidIndex(final int idx);					      	             
      }//end class Array

    繁重的工作获得元素索引

    getIndex()方法是Array.java类的核心功能。 getIndex()方法计算元素的内部一维线性或“平面”数组中的索引。 从编译器理论(这暗示了该理论,但更深入的解释超出了解释的范围),数组可以通过行主索引或列主索引来建立索引。 [Aho 2007]

    对于Array.java类,它是无关紧要的,只要函数对于数组实例的维边界的给定索引是一致的即可。 getIndex()方法的源代码是:

    int getIndex(final int... idx){                                                          
        isValidDims(idx);                                                                  
        int index = 0;                                                                     
        for(int x = 0; x < idx.length; x++) {                                             
          int i = idx[x];                                                                    
          for(int y = x + 1; y < idx.length; y++) {                                         
            i = i * dim[y];                                                                    
          }//end for                                                                                                                                                   
          index = index + i;                                                                 
        }//end for                                                                                                                                                        
        return index;                                                                          
      }//end getIndex

    getIndex()方法的源代码在实际计算内部线性数组中的一维索引之前,先验证索引的维度。

    索引验证

    有两种验证索引的方法。 一种是验证多维索引,另一种是验证单个索引。 验证一维索引的源代码为:

    void isValidIndex(final int idx){                                                        
        if(idx = this.size) throw new RuntimeException("Index Overflow Error!");             
      }//end isValidIndex

    isValidIndex()仅检查索引在数学上是否在零到内部数组整体大小的范围内。 如果索引不在该范围内,则会引发运行时未经检查的异常。 验证多维索引的源代码为:

    void isValidDims(final int... idx) {                                                   
        if(idx.length != this.dim.length) throw new RuntimeException("Rank Error");       
          for(int x = 0; x = dim[x]) throw new RuntimeException(“Index Overflow Error");         
            if(idx[x] < 0) throw new RuntimeException(“Index Underflow Error”);                            
          }//end for                                                                                                                                                    
      }//end isValidDims

    isValidDims()仅遍历每个维度参数,并检查索引的等级是否与数组的等级参数相同。 如果数组的等级和索引不相等,则会抛出运行时未经检查的异常RuntimeException。

    3.3其他非Varargs方法

    其他方法是非可变参数,它们不使用任何参数作为getter访问器方法,也可以采用单个参数。 这两种方法是:

    1. 查询数组参数
    2. 独特的阵列功能

    查询数组

    查询数组参数可以使用getter访问方法或使用参数来访问数组的参数。 该数组用于查询等级,整体大小,上部尺寸以及等级内特定索引处的尺寸。 用于查询Array.java类的数组方法的接口是:

    class Array {
        int getDim(final int dim);
        int[] getDims();
        int getRank();
        int size();					      	                                   
      }//end class Array

    独特的数组类功能

    独特的数组类功能是一个构造函数和两个提供独特功能的方法。 这两种方法是访问并转换为Array类实例的线性数组。 另一个功能是一个构造函数,该构造函数允许复制或复制Array类的实例。 Array.java类的功能是:

    class Array {
        Array(final Array array);
        E getAt(final int idx);
        Object[] toArray();							      
      }

    存取器为线性阵列

    getAt()方法允许访问数组元素,就像Array类实例是一维的“扁平”线性数组一样。 检查整数索引的有效性,并使用内部一维数组在有效位置返回元素。 作为线性数组访问的源代码为:

    E getAt(final int index) {                                                             
        this.isValidIndex(index); 				                                      
        return (E) this.data[index];                                                   
      }//end getAt

    转换为线性对象数组

    toArray()方法转换Array类实例,或者访问内部的一维数组并将其作为Object数组返回。 toArray()方法返回内部线性数组的浅表副本,而不是深表副本。 用于访问线性Object数组的getter访问器源代码为:

    Object[] toArray() {                                                                    
        return this.data;                                                              
      }//end toArray

    复制构造函数

    复制构造函数允许复制Array类实例,但将其复制为现有Array类实例的“深层”副本。 复制的数组和副本具有相同的类型参数,尺寸,等级和元素。 复制构造函数的源代码为:

    Array(final Array orig) {                                                              
        this.rank = orig.rank;                                                                       
        this.dim  = orig.dim;                                                                 
        this.size = orig.size;                                                               
        this.elem = (E) orig.elem;                                                    
        this.data = new Object[this.size];		                                    
        System.arraycopy(orig.data, 0, this.data, 0, this.size);                     
      }//end constructor copy

    System.arraycopy()复制原始文件,并为深度复制创建一个新的Object数组。 各种Array类实例参数被复制到深层副本中。

    4.使用通用数组类

    使用Java通用数组Array.java在源代码中通过两个用法示例进行了说明:

    1. 气泡排序算法
    2. 乘法表

    这两个示例都通过演示来说明如何使用通用数组类方法围绕数组创建,初始化,访问,查询和实现功能,但不使用内置Java数组。 源代码说明了源代码片段的输出。

    4.1气泡排序

    冒泡排序是一种基本的简单排序算法,但是非常适合说明Array.java通用数组类的用法。 冒泡排序是通过以下通用Java数组实现的:

    Array list = new Array(9).init(new Integer[]{3,5,7,4,8,0,2,1,6});  
      System.out.println(Arrays.toString(list.toArray()));                                  
            			        			                                                                                   
      boolean swapFlag = true;                                                               
      while(swapFlag) {                                                                       
        swapFlag = false;                                                                    
        for(int x=0;x 0) {                                     
            Integer temp = list.get(x);                                                       
            list.set( list.get(x+1), x);                                                      
            list.set( temp, (x+1));                                                         
            swapFlag = true;                                                                  
          }//end if                                                                                                                                                         
        }//end for                                                                                                                                                          
      }//end while                                                                                                                                                            
            			        			                                     
      System.out.println(Arrays.toString(list.toArray()));

    运行时,使用通用Java数组进行冒泡排序的输出为:

    [3, 5, 7, 4, 8, 0, 2, 1, 6]                                                              
    [0, 1, 2, 3, 4, 5, 6, 7, 8]

    4.2乘法表

    Java通用数组的一个基本示例性应用程序是创建一个简单的整数表(从1到10)。这需要二维整数数组。 创建乘法表后,将验证恒等式和可交换性的数学属性。 通用Java数组的这种用法的源代码为:

    Array multiplyTable = new Array(10,10).init(0);                    
      for(int x=0;x<multiplyTable.getDim(0);x++){                                            
        for(int y=0;y<multiplyTable.getDim(1);y++){                                            
          multiplyTable.set(x*y, x,y);		                                           
        }//end for                                                                                                                                                       
      }//end for                                                                                                                                                            
                                                                                		
      //check 1*n = n                                                                                                                                         
      for(int x=0;x<multiplyTable.getDim(0);x++){                                           
        if(multiplyTable.get(1,x) != x)                                                     
          throw new RuntimeException("Identity property doesn't hold!”);                     
        if(multiplyTable.get(x,1) != x)                                                    
          throw new RuntimeException("Identity property doesn't hold!”);                     
      }//end for   
                                                                          	 		        			                                                            
      //check m*n = n*m                                                                                                                                              
      for(int x=0;x<multiplyTable.getDim(0);x++){                                               
        for(int y=0;y<multiplyTable.getDim(1);y++){                                             
          if(multiplyTable.get(x,y) != multiplyTable.get(y,x) )                               
            throw new RuntimeException("Commutative property doesn't hold!");	                 
        }//end for                                                                                                                                                         
      }//end for

    没有输出,因为乘法的恒等式和交换数学属性是真实的,因此是有效的。 但这说明了二维通用数组的使用。 对于其他更高的尺寸,其他应用也是可能的。

    5.结论

    最初的问题证明了使用内置数组实体的参数化类型或通用数组的问题。 使用相同的代码片段,但替换通用数组Array.java,源代码为:

    class TestArray2 {                                                                                                                                                                                                                   
        public Array array = new Array(10);                                                                                                                                                                                              
      }//end class TestArray2

    编译时,没有报告的错误。 数据结构Array.java实现了原始问题的解决方案。

    Java中的类型参数化或泛型允许使用类型安全的类,但是在泛型类型参数化系统的设计中需要权衡取舍。 因此,Java中的泛型具有一些与内置Java数组实体有关的缺陷。 不幸的是,Java Collections Framework无法通过提供数组数据结构来解决该问题。

    解决方案在Java语言和通用类型参数化内。 只需将通用Array类设计为用Java编写的一流对象即可。 从表面上看,它似乎是现有Java实体(数组)的冗余副本。

    这不是复制; 设计Java Array类将创建一个通用的类型安全的数据结构,该结构可以替代内置Java数组实体。 折衷方案是在没有运算符重载的情况下,语法在数组访问和操作方面不太明确,但与在对象实例上调用方法一致。

    6.参考

    • [Aho 2007] Aho,Alfred V.,Lam,Monica S.,Sethi,Ravi和Ullman,Jeffrey D.编译器:原理,技术和工具,第二版。 皮尔逊教育公司(Pearson Education,Inc.),纽约,纽约,2007年,第381至382页。
    • [Goet 2019] Goetz,Brian。 “ Java理论与实践:泛型陷阱”,2005年1月25日。https ://www.ibm.com/developerworks/java/library/j-jtp01255/index.html,于2019年9月28日访问。

    7.下载源代码

    下载
    您可以在此处下载本文的完整源代码: 创建通用数组的问题

    翻译自: https://www.javacodegeeks.com/the-problem-with-creating-generic-arrays.html

    无法创建t的通用数组

    展开全文
  • Python Numpy 数组的基本操作

    千次阅读 2019-12-30 16:19:05
    Numpy是一个通用数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。 Numpy除了具有科学用途外,还可以作为通用数据的高效多维容器。 Numpy中的数组 Numpy中...

    Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象,以及处理这些数组的工具。它是Python科学计算的基本包。

    Numpy除了具有科学用途外,还可以作为通用数据的高效多维容器。

    Numpy中的数组

    Numpy中的数组是一个元素表(通常是数字),所有元素都是相同的类型,由一个正整数元组索引。在Numpy中,数组的维数称为数组的秩。一个整数的元组给出了数组在每个维度上的大小,称为数组的形状。Numpy中的数组类称为ndarray。Numpy数组中的元素可以使用方括号访问,也可以使用嵌套Python列表初始化。

    创建一个Numpy数组

    Numpy中的数组可以通过多种方式创建,具有不同数量的秩,定义数组的大小。数组还可以使用各种数据类型(如列表、元组等)创建。合成阵列的类型由序列中元素的类型导出。

    注意:可以在创建数组时显式定义数组的类型。

    # Python程序
    # 数组的创建
    import numpy as np
    
    #  创建rank 1数组
    arr = np.array([1, 2, 3])
    print("Array with Rank 1: \n",arr)
    
    #  创建rank 2数组
    arr = np.array([[1, 2, 3],
                    [4, 5, 6]])
    print("Array with Rank 2: \n", arr)
    
    # 从元组创建一个数组
    arr = np.array((1, 3, 2))
    print("\nArray created using "
          "passed tuple:\n", arr)
    

    输出如下:

    Array with Rank 1:
     [1 2 3]
    Array with Rank 2:
     [[1 2 3]
     [4 5 6]]

    Array created using passed tuple:
     [1 3 2]

    访问数组索引

    在numpy数组中,索引或访问数组索引可以通过多种方式完成。要打印一系列数组,请完成切片。切片数组是在新数组中定义一个范围,用于从原始数组中打印一系列元素。由于切片数组包含原始数组的一系列元素,因此在切片数组的帮助下修改内容会修改原始数组内容。

    #Pthon程序来演示
    #numpy数组中的索引
    import numpy as np
    
    #初始数组
    arr = np.array([[-1, 2, 0, 4],
                    [4, -0.5, 6, 0],
                    [2.6, 0, 7, 8],
                    [3, -7, 4, 2.0]])
    print("Initial Array: ")
    print(arr)
    
    #打印数组的范围
    #使用切片方法
    sliced_arr = arr[:2, ::2]
    print ("Array with first 2 rows and"
        " alternate columns(0 and 2):\n", sliced_arr)
    
    #打印元素
    #specific Indices
    Index_arr = arr[[1, 1, 0, 3],
                    [3, 2, 1, 0]]
    print ("\nElements at indices (1, 3), "
        "(1, 2), (0, 1), (3, 0):\n", Index_arr)
    

     

    输出如下:

    Initial Array:
    [[-1.  2.  0.  4. ]
     [ 4.  -0.5  6.  0. ]
     [ 2.6  0.  7.  8. ]
     [ 3.  -7.  4.  2. ]]
    Array with first 2 rows and alternate columns(0 and 2):
     [[-1.  0.]
     [ 4.  6.]]

    Elements at indices (1, 3), (1, 2), (0, 1), (3, 0):
     [0. 6. 2. 3.]

    基本阵列操作

    在numpy中,数组允许可以在特定阵列或阵列组合上执行的各种操作。这些操作包括一些基本的数学运算以及一元和二元运算。

    #Pthon程序来演示
    #单个阵列的基本操作
    import numpy as np
    
    #定义数组1
    a = np.array([[1, 2],
                  [3, 4]])
    
    # Defining Array 2
    b = np.array([[4, 3],
                  [2, 1]])
    
    #向每个元素添加1
    print ("Adding 1 to every element:", a + 1)
    
    # 每个元素减去2
    print ("\nSubtracting 2 from each element:", b - 2)
    
    # 数组元素和
    # 执行一元操作
    print ("\nSum of all array "
           "elements: ", a.sum())
    
    #添加两个数组
    #执行二进制操作
    print ("\nArray sum:\n", a + b)
    

    输出如下:

    Adding 1 to every element: [[2 3]
     [4 5]]

    Subtracting 2 from each element: [[ 2  1]
     [ 0 -1]]

    Sum of all array elements:  10

    Array sum:
     [[5 5]
     [5 5]]

    Numpy中的数据类型

    每个Numpy数组都是一个元素表(通常是数字),都是相同的类型,由正整数元组索引。每个ndarray都有一个关联的数据类型(dtype)对象。此数据类型对象(dtype)提供有关阵列布局的信息。ndarray的值存储在缓冲区中,缓冲区可以被认为是可以由dtype对象解释的连续的存储器字节块。Numpy提供了大量可用于构造数组的数值数据类型。在创建数组时,Numpy尝试猜测数据类型,但构造数组的函数通常还包含一个可选参数来显式指定数据类型。

    构造数据类型对象

    在Numpy中,除非需要特定的数据类型,否则无需定义数组的数据类型。Numpy试图猜测构造函数中未预定义的数组的数据类型。

    #Python程序创建
    #数据类型对象
    import numpy as np
    
    #整数数据类型
    x = np.array([1, 2])
    print("Integer Datatype: ")
    print(x.dtype)
    
    #浮动数据类型
    x = np.array([1.0, 2.0])
    print("\nFloat Datatype: ")
    print(x.dtype)
    
    # 强制数据类型
    x = np.array([1, 2], dtype = np.int64)
    print("\nForcing a Datatype: ")
    print(x.dtype)
    

    Integer Datatype:
    int64

    Float Datatype:
    float64

    Forcing a Datatype:
    int64

    DataType数组上的数学运算

    在Numpy数组中,基本数学运算在数组上以元素方式执行。这些操作既可以作为操作符重载也可以作为函数应用。Numpy中提供了许多有用的函数,用于对数组执行计算,例如sum:用于添加数组元素,T:用于元素的转置等。

    #Python程序创建
    #数据类型对象
    import numpy as np
    
    #第一个数组
    arr1 = np.array([[4, 7], [2, 6]],
                     dtype = np.float64)
    
    #第二个数组
    arr2 = np.array([[3, 6], [2, 8]],
                     dtype = np.float64)
    
    #添加两个阵列
    Sum = np.add(arr1, arr2)
    print("Addition of Two Arrays: ")
    print(Sum)
    
    #添加所有数组元素
    #使用预定义的sum方法
    Sum1 = np.sum(arr1)
    print("\nAddition of Array elements: ")
    print(Sum1)
    
    # 数组的平方根
    Sqrt = np.sqrt(arr1)
    print("\nSquare root of Array1 elements: ")
    print(Sqrt)
    
    #数组转置
    #使用内置功能'T'
    Trans_arr = arr1.T
    print("\nTranspose of Array: ")
    print(Trans_arr)
    

    输出如下:

    Addition of Two Arrays:
    [[ 7. 13.]
     [ 4. 14.]]

    Addition of Array elements:
    19.0

    Square root of Array1 elements:
    [[2.        2.64575131]
     [1.41421356 2.44948974]]

    Transpose of Array:
    [[4. 2.]
     [7. 6.]]

    展开全文
  • jQuery对于数组元素操作主要提供了以下工具: (1)数组和对象的例遍:jQuery.each(obj,callback) 通用例遍方法,可用于例遍对象和数组。回调函数拥有两个参数:第一个为对象的成员或数组的索引,第二个为对应变量或...
  • JNI数组操作

    千次阅读 2019-06-25 16:22:00
    在Java中数组分为两种: ...一个能通用于两种不同类型数组的函数: GetArrayLength(jarray array); 首先来看一下怎么处理基本类型的数组: (1) GetArrayElements(Array arr , jboolean* isCopide); 这函数...
  • 对象数组可用于任何数组操作,可以将任何都变成一个数组进行操作,并且也可以非常方便的添加,删除和修改。 一、添加成员 1、首先简单的定义三个文本数组的变量做演示,在“创建完毕”事件下面分别给...
  • 通用类型的模板数组定义如下 template< class T> class MyArray { public: //构造 explicit MyArray(int capacity) //防止隐式类型转换 防止MyArray arr = 10; 写法 { this->m_Capacity = ...
  • 8、NumPy 基础:N维数组通用函数

    千次阅读 2017-03-20 22:36:26
    N维数组对象(ndarray),该对象是一个快速而灵活的大数据集容器 具有矢量运算和复杂广播能力 具有用于对整组数据进行快速运算的标准数学函数(无需编写循环) 具有线性代数、随机数生成以及傅里叶变换功能 Numpy 可以...
  • 一、数组、对象、类数组对象数据结构的异同1、数组 一组有序的数据集合,其索引为从0开始且自然增长的整数,其元素值可以是任何js数据!并且包含一个名为length的属性,该属性表示数组元素的个数!var array = [1,2...
  • C# 数据库操作通用类(增删改查)

    千次阅读 2018-11-27 20:03:25
    数据库操作通用类 优点:达到了sql防注入,并且,将对数据库的操作独立开来,可以提高内聚,降低耦合。达到了哪里使用,哪里关闭的效果,避免隐患。 public class SqlHelper { SqlConnection conn = null; ...
  • Excel输出打印模块,将DataTable数据写入Excel文件(自动分页),将DataTable数据写入Excel文件(不分页),将DataTable数据写入Excel文件(自动分页,并指定要合并的列索引) , 将二维数组数据写入Excel文件(自动...
  • Matlab创建一维数组的具体操作讲解

    千次阅读 2021-04-18 14:54:11
    最近不少网友表示自己刚刚入手Matlab软件,还不会创建一维数组,而下面这篇文章就是为大家专门讲解Matlab创建一维数组的具体操作内容,有需要学习的小伙伴就赶紧和小编一起来看看吧。一,直接输入法创建一维行数组。...
  • Matlab创建一维数组的具体操作方法

    千次阅读 2021-04-18 14:54:29
    现在使用Matlab的朋友越来越多,而接下里的这篇文章绿软吧就带来了Matlab创建一维数组的具体操作方法,感兴趣的朋友就跟绿软吧一起来学习一下吧。Matlab创建一维数组的具体操作方法一,直接输入法创建一维行数组。在...
  • 清除数组和数组清零是易语言数组操作中两个容易混淆的命令,视频教程举例做了示范。 511遇见易语言教程 官方文档 清除数组 调用格式: 〈无返回值〉 清除数组 (通用型变量数组 欲删除成员的数组变量) - 系统...
  • 这个例子就是自定义一个数组模板,需要实现数组的一些常用操作。例如拷贝,有参构造,查找,删除等。 1.自定义数组类需求 模板案例描述:实现一个通用数组类,要求如下 1)可以对内置数据类型以及自定义...
  • java中数组数组元素的相关操作

    千次阅读 2019-06-12 15:19:03
    数组及相关方法 数组简介: 数组是一种重要的数据结构,在很多语言中都非常重要,并且像 栈,链表这些实现的 基础就是数组,更能看出数组的重要性。 数组的声明: 使用数组的前提就是声明数组变量: 通用...
  • 此函数不关心表结构,只需要指定表名、结构和查询条件既可以对表进行通用查询操作,非常实用。 function listmytablerows($table, $name, $field, $where, $textID) { / / Connect to the database and query ...
  • 高阶数组操作 一、重塑数组 在很多情况下,我们将数组从一个形状转换为另一个形状,并且不复制任何数据。为了实现这个功能,可以向reshape数组实例方法传递一个表示新形状的元组。例如,假设我们有一个一维数组...
  • 定义数组const array = [1, 2, 3];或者const array = new Array();array[0] = '1';建议尽量使用第一种形式定义数组,采用new的形式在大量的数组定义时,会...在Javascript里分配大量的new变量地址是一项很慢的操作,...
  • vue 观察数组的变异方法 更新视图push()pop()shift()unshift()splice(i,n,arr)sort(xx)reverse()ex: app.book.push({name:'css',author:'lee'})有些方法不会改变数组filter()concat()slice()返回新数组 需要用 新...
  • 前面有几条都讲过关于Array.prototype的...它是一个类数组对象,并不是一个标准的数组,所以无法使用数组原型中的方法,因此无法使用arguments.forEach这样的形式来遍历每一个参数。这里我们必须使用call方法来对使用fo
  • js数组操作大全

    千次阅读 2018-03-26 10:35:59
    shift:删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined var a = [1,2,3,4,5]; var b = a.shift(); //a:[2,3,4,5] b:1 unshift:将参数添加到原数组开头,并返回数组的长度 var a = [1,2,3,4,5...
  • jni 操作 java 数组

    千次阅读 2018-06-12 10:52:49
    在 jni 函数中对 java 数组操作主要包含以下几: GetArrayLength(jarray array) 用于返回 java 数组的数据长度 jstring stringFromJNI(JNIEnv *env, jobject thiz, jintArray intArray){ __android_log_...
  • 模板 通用数组的实现

    千次阅读 2017-09-26 10:30:30
    实现自定义数组, 重载[] , 头文件 #ifndef __MYARRAY_H__ #define __MYARRAY_H__ #include using namespace std; template class MyArray { friend ostream & operator( ostream &out, const MyArray &obj);...
  • shift:删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined var a = [1,2,3,4,5]; var b = a.shift(); //a:[2,3,4,5] b:1 unshift:将参数添加到原数组开头,并返回数组的长度 ...
  • 511遇见易语言数组操作数组排序

    千次阅读 2020-06-24 09:34:12
    本课将的数组排序是易语言数组操作中的核心命令,是易语言封装好的排序方法,我们还要在后续课程中讲解一起其他排序方法,比如冒泡排序,选择法排序,折半法排序,交换法排序等等...易语言经典排序算法系列 511...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,636
精华内容 94,254
关键字:

数组操作通用类