原标题：Python Numpy 数组的基本操作示例
Numpy是一个通用的数组处理包。它提供了一个高性能的多维数组对象，以及处理这些数组的工具。它是Python科学计算的基本包。
Numpy除了具有明显的科学用途外，还可以作为通用数据的高效多维容器。
Numpy中的数组
Numpy中的数组是一个元素表(通常是数字)，所有元素都是相同的类型，由一个正整数元组索引。在Numpy中，数组的维数称为数组的秩。一个整数的元组给出了数组在每个维度上的大小，称为数组的形状。Numpy中的数组类称为ndarray。Numpy数组中的元素可以使用方括号访问，也可以使用嵌套Python列表初始化。
创建一个Numpy数组
Numpy中的数组可以通过多种方式创建，具有不同数量的秩，定义数组的大小。数组还可以使用各种数据类型(如列表、元组等)创建。合成阵列的类型由序列中元素的类型导出。
注意:可以在创建数组时显式定义数组的类型。
# Python程序
# 数组的创建
importnumpy asnp
# 创建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数组中的索引
importnumpy asnp
#初始数组
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程序来演示
#单个阵列的基本操作
importnumpy asnp
#定义数组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程序创建
#数据类型对象
importnumpy asnp
#整数数据类型
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程序创建
#数据类型对象
importnumpy asnp
#第一个数组
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.]]
更多Python相关信息见Python 专题页面 https://www.linuxidc.com/topicnews.aspx?tid=17
Linux公社的RSS地址：https://www.linuxidc.com/rssFeed.aspx
本文永久更新链接地址：https://www.linuxidc.com/Linux/2019-05/158506.htm返回搜狐，查看更多
责任编辑：

Java数组的基本操作方法整理
这篇文章主要介绍了Java数组的基本操作方法整理，是Java入门学习中的基础知识，需要的朋友可以参考下
数组是具有相同数据类型的一组数据的集合，Java支持多为数组，一维数组的每个基本单元都是基本数据类型的数据，二维数组就是每个基本单元是一维数组的一维数组，以此类推，n维数组的每个基本单元都是n-1为数组的n-1维数组。下面以一维数组为例说明Java数组的用法。
1、数组声明
数组声明有如下两种形式(方括号的位置不同)：
int arr［］;
int［］ arr2;
2、数组初始化
数组初始化也有两种形式，如下(使用new或不使用new)：
int arr［］ = new int［］{1， 3， 5， 7， 9};
int［］ arr2 = {2， 4， 6， 8， 10};
3、遍历数组
遍历数组可用for/foreach，如下：
public staTIc void main(String［］ args) {
int arr［］ = new int［］{1， 3， 5， 7 ，9};
int［］ arr2 = {2， 4， 6， 8， 10};
for (int i = 0; i 《 arr.length; ++i) {
System.out.print(arr［i］ + “\t”); // 1 3 5 7 9
}
for (int x： arr2) {
System.out.print(x + “\t”); // 2 4 6 8 10
}
}
4、Arrays.fill()填充数组
使用Arrays类的静态方法，需要import包java.uTIl.Arrays，定义了许多重载方法。
void fill(int［］ a， int val)全部填充
void fill(int［］ a， int fromIndex， int toIndex， int val)填充指定索引的元素
int［］ arr3 = new int［5］;
for (int x： arr3) {
System.out.print(x + “\t”); // 0 0 0 0 0 全部初始化为0
}
System.out.println();
Arrays.fill(arr3， 10);
for (int x： arr3) {
System.out.print(x + “\t”); // 10 10 10 10 10 全部填充为10
}
System.out.println();
Arrays.fill(arr3， 1， 3， 8);
for (int x： arr3) {
System.out.print(x + “\t”); // 10 8 8 10 10 填充指定索引
}
System.out.println();
5、Arrays.sort()对数组排序
void sort(int［］ a)全部排序
void sort(int［］ a， int fromIndex， int toIndex)排序指定索引的元素
int［］ arr4 = {3， 7， 2， 1， 9};
Arrays.sort(arr4);
for (int x： arr4) {
System.out.print(x + “\t”); // 1 2 3 7 9
}
System.out.println();
int［］ arr5 = {3， 7， 2， 1， 9};
Arrays.sort(arr5， 1， 3);
for (int x： arr5) {
System.out.print(x + “\t”); // 3 2 7 1 9
}
System.out.println();
6、Arrays.copyOf()复制数组
int［］ copyOf(int［］ original， int newLength)复制数组，指定新数组长度
int［］ copyOfRange(int［］ original， int from， int to)复制数组，指定所复制的原数组的索引
int［］ arr6 = {1， 2， 3， 4， 5};
int［］ arr7 = Arrays.copyOf(arr6， 5); // 1 2 3 4 5
int［］ arr8 = Arrays.copyOfRange(arr6， 1， 3); // 2 3
for (int x： arr7) {
System.out.print(x + “\t”);
}
System.out.println();
for (int x： arr8) {
System.out.print(x + “\t”);
}
System.out.println();
7、检查数组中是否包含某一个值
String［］ stringArray = { “a”， “b”， “c”， “d”， “e” };
boolean b = Arrays.asList(stringArray).contains(“a”);
System.out.println(b);
// true
先使用Arrays.asList()将Array转换成List《String》，这样就可以用动态链表的contains函数来判断元素是否包含在链表中。
8、连接两个数组
int［］ intArray = { 1， 2， 3， 4， 5 };
int［］ intArray2 = { 6， 7， 8， 9， 10 };
// Apache Commons Lang library
int［］ combinedIntArray = ArrayUTIls.addAll(intArray， intArray2);
ArrayUTIls是Apache提供的数组处理类库，其addAll方法可以很方便地将两个数组连接成一个数组。
9、数组翻转
int［］ intArray = { 1， 2， 3， 4， 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//［5， 4， 3， 2， 1］
依然用到了万能的ArrayUtils。
10、从数组中移除一个元素
int［］ intArray = { 1， 2， 3， 4， 5 };
int［］ removed = ArrayUtils.removeElement(intArray， 3);//create a new array
System.out.println(Arrays.toString(removed));

问题：
利用数组的基本运算队数组进行初始化，然后输出数组的值
涉及到数组的基本操作：初始化，赋值，定位，销毁等
代码：
头文件“SeqArray.h"
#pragma once
#define  MaxArraySize 3
#include<stdarg.h>
#include <stdio.h>
#include<stdlib.h>


typedef struct
{
	DataType *base;
	int  dim;// 数组的维数
	int *bounds; // 数组的每一位界限间的地址
	int *constants; //数组存储映像常量地址，里面的数据用来数组元素定位


}Array;

int InitArray(Array *A, int dim, ...)
/*初始化数组，根据数组的维数和各维的长度构造一个数组，为数组的所有元素分配内存单元，确定每一维的界限
地址，便于以后为数组赋值和获取数组中的元素，构造成功则返回1*/
{
	int i;
	int ElemTotal = 1;
	va_list ap;
	if (dim < 1 || dim >MaxArraySize)
	{
		return 0;
	}
	A->dim = dim;
	A->bounds = (int*)malloc(dim * sizeof(int));
	if (!A->bounds)
		exit(-1);
	va_start(ap, dim);
	for (i = 0; i < dim; i++)
	{
		A->bounds[i] = va_arg(ap, int);//依次获得各维参数，即各维的长度
		if (A->bounds[i] < 0)
			return -1;
		ElemTotal *= A->bounds[i];
	}
	va_end(ap);
	A->base = (DataType*)malloc(ElemTotal * sizeof(DataType)); // 为数组所有元素分配空间
	if (!A->base)
		exit(-1);
	A->constants = (int*)malloc(dim * sizeof(int));//为数组的常量基址分配内存单元
	if (!A->constants)
		exit(-1);
	A->constants[dim - 1] = 1;
	for (i = dim - 2; i >= 0; i--)
	{
		A->constants[i] = A->bounds[i + 1] * A->constants[i + 1];
	}
	return 1;
}

int LocateArray(Array A, va_list ap, int *offset)
/*根据数组中元素的下标，求出该元素在数组中的相对位置*/
{
	int i, instand;
	*offset = 0;
	for (i = 0; i < A.dim; i++)
	{
		instand = va_arg(ap, int);//一个一个把取值出来
		if (instand < 0 || instand >= A.bounds[i])
			return 0;
		*offset += A.constants[i] * instand;

	}
	return 1;
}

int  AssignValue(Array A, DataType e, ...)
/*数组的赋值操作，将e的值赋给指定的数组元素，...为坐标*/
{
	va_list ap;//指向可变参数的指针
	va_start(ap, e);//ap指向e的下一个参数。。。
	int offset;
	if (LocateArray(A, ap, &offset) == 0)
		return 0;
	va_end(ap);
	*(A.base + offset) = e;
	return 1;
}

int GetValue(DataType *e, Array A, ...)
/*返回数组中指定的元素*/
{
	va_list ap;
	int offset;
	va_start(ap, A);
	if (LocateArray(A, ap, &offset) == 0)
		return -1;
	va_end(ap);
	(*e) = *(A.base+offset);
	return 1;

}

void DestroyArray(Array *A)
/*销毁数组*/
{
	if (A->base)
		free(A);
	if (A->bounds)
		free(A->bounds);
	if (A->constants)
		free(A->constants);
	A->base = A->constants = A->bounds = NULL;
	A->dim = 0;
}

源文件
// SeqArray.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//利用数组的基本运算队数组进行初始化，然后输出数组的值

#include "pch.h"
#include <iostream>
typedef int DataType;
#include"SeqArray.h"


int main()
{
	Array A;
	int i, j, k;
	int dim = 3;
	int bound1 = 5, bound2 = 3, bound3 = 2;//初始化数组的维数和各维的长度
	DataType e;
	InitArray(&A, dim, bound1, bound2, bound3);
	std::cout << "数组A的各维长度是：\n";
	for (i = 0; i < dim; i++)
	{
		printf("%3d", A.bounds[i]);
	}
	printf("\n");
	std::cout << "数组A的常量基值是：";
	for (i = 0; i < dim; i++)
	{
		printf("%3d", A.constants[i]);
	}
	printf("\n");
	printf("数组A[%d][%d][%d]的元素如下", bound1, bound2, bound3);
	for (i = 0; i < bound1; i++)
	{
		for (j = 0; j < bound2; j++)
		{
			for (k = 0; k < bound3; k++)
			{
				AssignValue(A, 100 * i + 10 * j + k, i, j, k);
				GetValue(&e, A, i, j, k);//把该元素赋值e
				printf("A[%d][%d][%d] = %3d   ", i, j, k, e);
			}
			printf("\n");
		}
		printf("\n");
	}

	printf("按照数组的先行序列输出元素，利用基地址输出元素:\n");
	for (i = 0; i < bound1*bound2*bound3; i++)
	{
		printf("第%d个元素 = %3d\t", i + 1, *(A.base + i));
		if ((i + 1) % bound2 == 0)
			printf("\n");
	}
	DestroyArray(&A);
}

数组的基本操作
1、往数组中添加一个元素：

push方法（在尾部添加）unshift方法（在头部添加）

二者均返回数组长度



2、从数组中删除一个元素：

pop() 方法（在尾部删除）shift() 方法（在头部删除）

二者均返回删除元素

总结：push()、pop()、shift()、unshift()都会改变原数组

3、提取数组中的一部分

slice() 方法：slice（开始位置，结束位置）

若只有一个参数，即无结束位置参数，则从开始到结束

若结束位置大于开始位置，则返回空数组
其中计算时不包括结束位置，不改变原素组，返回提取的新数组

当位置上的数字为正时：



当位置上的数字小于0时：



最后，原数组不改变



4、删除数组中的一部分元素

最终操作的结果会改变原数组

splice()方法：splice（开始位置，删除个数）返回删除的元素



splice（开始位置，删除个数，插入元素）

负数表示从倒数开始计算



5、reverse（）

将数组中的元素逆转放置，操作改变原数组



6、sort（）

sort() 方法用于对数组的元素进行排序。

请注意，下面的代码没有按照数值的大小对数字进行排序，而是按照字典进行排序

操作会改变原数组



7、join（）

join() 方法用于把数组中的所有元素放入一个字符串。

元素是通过指定的分隔符进行分隔的。

若括号里什么都不写，则默认用逗号分隔

若是引号，则空白分隔





8、for…in 遍历数组



for in 会遍历数组内所有可枚举的属性，包括原型上的属性和方法，如下：



所以，for in更适合遍历对象，尽量不要使用for in 遍历数组

使用for in 遍历对象时，index为该对象的键，Object[index]能取到每个键对应的值，来看下面的例子：



9、concat() （连接两个或多个数组）

concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。
<script>
	var arr=[1,2,3,4];
	var arr2=[11,12,13] 
	var arrCopy = arr.concat(arr2);
	console.log(arr.concat()); // [1, 2, 3, 4] (复制数组)
	console.log(arrCopy); // [1, 2, 3, 4, 11, 12, 13]
	console.log(arr); // [1, 2, 3, 4] (原数组未改变)
</script>

如果传入的参数是一个二维数组呢？
<script>
	var arr=[1,2,3,4];
	var arr2=[11,[12,13]] 
	var arrCopy = arr.concat(arr2);	
	console.log(arrCopy); // [1, 2, 3, 4, 11, Array(2)]
	console.log(arr); // [1, 2, 3, 4] (原数组未改变)
</script>

从上面代码中可以看出concat方法只能将传入数组中的每一项添加到数组中，如果传入数组中有些项是数组，那么也会把这一数组项当作一项添加到arrCopy中。
9、map()函数
和foreach类似，此方法是将数组中的每个元素调用一个提供的函数，结果作为一个新的数组返回，并没有改变原来的数组，(map也会把数组的每一项都遍历一遍)，值得注意的是，map不会对空数组进行检测



5个迭代方法：forEach()、map()、filter()、some()、every()

10、foreach()函数

foreach会从头到尾对数组里的每个元素遍历一遍 ，他不会生成新数组，也不改变原数组，回调函数接收三个值，分别是 数组的元素，索引和当前数组。


11、Array.map()
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

map() 方法按照原始数组元素顺序依次处理元素。

注意： map() 不会对空数组进行检测。

注意： map() 不会改变原始数组。
12、filter()函数

filter为过滤的意思，也就是说它会把满足条件的元素拿出来形成一个新的数组



13、Array.every()

接收参数：array.every(function(currentValue,index,arr), thisValue)
thisValue ：可选。对象作为该执行回调时使用，传递给函数，用作 “this” 的值。

如果省略了 thisValue ，“this” 的值为 “undefined”
此方法是将所有元素进行判断返回一个布尔值，如果所有元素都满足判断条件，则返回true，否则为false：
	let arr = [1, 2, 3, 4, 5]
    const h1 = value => value < 4
    const h2 = value => value < 6
    arr.every(h1 ) //false
    arr.every(h2 ) //true

14、Array.some()
此方法是将所有元素进行判断返回一个布尔值，如果存在元素都满足判断条件，则返回true，若所有元素都不满足判断条件，则返回false：
	let arr= [1, 2, 3, 4, 5]
    const h1 = value => value < 4
    const h2 = value => value > 6
    arr.some(h1) //true
    arr.some(h2 ) //false

15、Array.reduce()
此方法是所有元素调用返回函数，返回值为最后结果,传入的值必须是函数类型：
   let arr = [1, 2, 3, 4, 5]
   const add = (a, b) => a + b
   let sum = arr.reduce(add)
   //sum = 15  相当于累加的效果

与之相对应的还有一个 Array.reduceRight() 方法，区别是这个是从右向左操作的
16、Array.indexOf(item,start)
indexOf() 方法可返回数组中某个指定的元素位置。

该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。

如果在数组中没找到指定元素则返回 -1。
var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
var a = fruits.indexOf("Apple",4); //结果为 6

17、Array.lastIndexOf(item,start)
lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。

如果要检索的元素没有出现，则该方法返回 -1。

该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。

如果在数组中没找到指定元素则返回 -1。
Es6新增数组方法：

1、Array.fill()

fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。


arr.fill(value[, start[, end]])
value

用来填充数组元素的值。

start 可选

起始索引，默认值为0。

end 可选

终止索引，默认值为 this.length。


例子

[1, 2, 3].fill(4);               // [4, 4, 4]

[1, 2, 3].fill(4, 1);            // [1, 4, 4]

[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]

[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]

[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]

[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]

[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]

[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]

Array(3).fill(4);                // [4, 4, 4]

[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
// Objects by reference.

var arr = Array(3).fill({}) // [{}, {}, {}];

arr[0].hi = “hi”; // [{ hi: “hi” }, { hi: “hi” }, { hi: “hi” }]