Python numpy实现二维数组和一维数组拼接的方法

撰写时间：2017.5.23

一维数组

1.numpy初始化一维数组

a = np.array([1,2,3]);

print a.shape

输出的值应该为（3，）

二维数组

2.numpy初始化二维数组

a = np.array([[1,2,3]]);

b = np.array([[1],[2],[3]]);

print a.shape//(1，3）

print b.shape//（3,1）

注意（3，）和（3,1）的数组是不一样的，前者是一维数组，后者是二维数组。

拼接

3.numpy有很多的拼接函数。比如hstack和vstack等。网上又很多这样的总结帖子。但是两个数组能拼接的条件就是得满足两个数组的维度要相同。所以二维数组和一维数组拼接的时候需要使用newaxis将一维数组转化为二维数组，也就是shape从（3，）转化为（3,1）。

a = np.array([1,2,3]);

b = np.array([[1],[2],[3]]);

#将一维数组a转化为二维数组

a = a[:,np.newaxis];

c = np.concatenate((b,a),axis=1)

print c.shape//输出为（3,2）

以上这篇Python numpy实现二维数组和一维数组拼接的方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我们。

时间： 2018-06-02

最近找遍了python的各个函数发现无法直接生成随机的二维数组,其中包括random()相关的各种方法,都没有得到想要的结果.最后在一篇博客中受到启发,通过列表解析的方法得到随机的二维数组. 具体如下: a = [[random.randint(1, 4) for j in range(1, 3)] for i in range(1, 11)] print(array(a)) 其中random.randint(1, 4)用来产生一个随机整数.此时创建了一个10行2列的数组. [[1 3] [1

关于python中的二维数组,主要有list和numpy.array两种. 好吧,其实还有matrices,但它必须是2维的,而numpy arrays (ndarrays) 可以是多维的. 我们主要讨论list和numpy.array的区别: 我们可以通过以下的代码看出二者的区别 >>import numpy as np >>a=[[1,2,3],[4,5,6],[7,8,9]] >>a [[1,2,3],[4,5,6],[7,8,9]] >>type(a

题目的意思大致是在一个n*m的二维数组中,找到一个局部峰值.峰值要求大于相邻的四个元素(数组边界以外视为负无穷),比如最后我们找到峰值A[j][i],则有A[j][i] > A[j+1][i] && A[j][i] > A[j-1][i] && A[j][i] > A[j][i+1] && A[j][i] > A[j][i-1].返回该峰值的坐标和值. 当然,最简单直接的方法就是遍历所有数组元素,判断是否为峰值,时间复杂度为O(n^2

本文实例讲述了Python实现二维数组按照某行或列排序的方法.分享给大家供大家参考,具体如下: lexsort支持对数组按指定行或列的顺序排序:是间接排序,lexsort不修改原数组,返回索引. (对应lexsort 一维数组的是argsort a.argsort()这么使用就可以:argsort也不修改原数组, 返回索引) 默认按最后一行元素有小到大排序, 返回最后一行元素排序后索引所在位置. 设数组a, 返回的索引ind,ind返回的是一维数组 对于一维数组, a[ind]就是排序后的数组.

本文实例讲述了Python简单获取二维数组行列数的方法.分享给大家供大家参考,具体如下: import numpy as np x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]]) # 输出数组的行和列数 print x.shape # (4, 3) # 只输出行数 print x.shape[0] # 4 # 只输出列数 print x.shape[1] # 3 本机测试运行结果如下图所示: 或者: >>> arr = [[1,4,7,10,1

二维数组 二维数组本质上是以数组作为数组元素的数组,即"数组的数组",类型说明符 数组名[常量表达式][常量表达式].二维数组又称为矩阵,行列数相等的矩阵称为方阵.对称矩阵a[i][j] = a[j][i],对角矩阵:n阶方阵主对角线外都是零元素. Python中创建二维数组 Python中的列表list可以当做一维数组使用,但是没有直接的定义使用二维数组.如果直接使用a = [][]会产生SyntaxError: invalid syntax语法不正确错误. 一般Python中创建二

前不久对于Python输入二维数组有些不解,今日成功尝试,记以备忘.这里以输入1-9,3*3矩阵为例 n=int(input()) line=[[0]*n]*n for i in range(n): line[i]=input().split(' ') print(line) 使用数据转换为int即可! 以上这篇Python输入二维数组方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们. 您可能感兴趣的文章: 一些Python中的二维数组的操作方法 python中字

有一道算法题题目的意思是在二维数组里找到一个峰值.要求复杂度为n. 解题思路是找田字(四边和中间横竖两行)中最大值,用分治法递归下一个象限的田字. 在用python定义一个二维数组时可以有list和numpy.array两种方式,看了几篇python中二维数组的建立的博客发现大多都是建立的初始化的二维数组,而我需要通过文件读取得到的是字符串,再把字符串转换为二维数组,找不到解决方法还是决定自己来转换. 首先,最开始的字符串输出如下,数字之间有空格 思路就是把先按换行符进行切片,再对每一行的字符再

0.目录 1.遇到的问题 2.创建二维数组的办法 •3.1 直接创建法 •3.2 列表生成式法 •3.3 使用模块numpy创建 1.遇到的问题 今天写Python代码的时候遇到了一个大坑,差点就耽误我交作业了... 问题是这样的,我需要创建一个二维数组,如下: m = n = 3 test = [[0] * m] * n print("test =", test) 输出结果如下: test = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] 是不是看起来没有一点问

使用new 创建二维数组方法 #include using namespace std; void main() { //用new创建一个二维数组,有两种方法,是等价的 //一: int (*p)[10] = new int[5][10]; //二: int **p = new int* [5]; for(int i=0;i <5;i++) p[i] = new int[10]; //指针数组的创建,也有两种方法 //一: char **pa = new char*

对于二维数组,img_mask [[ 0 0 0 ..., 7 7 7] [ 0 0 0 ..., 7 7 7] [ 0 0 0 ..., 7 7 7] ..., [266 266 266 ..., 253 253 253] [266 266 266 ..., 253 253 253] [266 266 266 ..., 253 253 253]] 显示为图片的代码为: import matplotlib.pyplot as pyplot pyplot.imshow(im_mask) 以上这篇P

本文实例为大家分享了C++利用函数动态创建二维数组的具体代码,供大家参考,具体内容如下 很简单,使用两个new创建即可. 运行截图及代码如下: #include #include #include #include using namespace std; int **creat(int m,int n) { int **p; int i,j; p = new int *[m]; f

简介:由于经常在使用矩阵进行计算时,会首先将一维数组转为二维数组.因此,在这里记录一下,也希望对他人有帮助. 实例代码: package deal; public class ArryTest { public static void main(String[] args) { //创建一个一维数组 0,1,2,3...,10 double [] c= new double[10]; for (int i = 0; i < c.length; i++) { c[i]=i; } double[][

1. 二维数组的创建:

int arr[][];
long arr[][]; 
double arr[][];

在这,格式就是数据类型 数组名称 [ 数组的行] [ 数组的列 ];

int arr [ 3 ][ 4 ];此时就写了一个数组,这个二维数组的长度就是3行4列.

2. 二维数组的初始化:

int arr [3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

此时就是对这个二维数组进行了初始化,对这个二维数组添加了数据元素.那么此时这个二维数组初始化以后的状态就是

1	2	3	4
5	6	7	8
9	10	11	12

int arr [3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

int arr [][4] = {1,2,3,4,5,6,7,8,9,10,11,12}

对二维数组这样的遍历也是可以得到上面的情况的.

注意在二维数组的初始化时,二维数组的列是不可以省略的.

下面我们来输出一下这个二维数组:

#include<stdio.h> 
int main(){
int arr [3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
int i = 0; 
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            printf("%d", arr[i][j]);//打印这个数组
        }
       printf("\n");
     }
}

 

上面代码运行以后就是我们二维数组的打印.

那么二维数组的数据元素并不是固定的嘛,那我们就来给这个二维数组添加可以自己增加数据元素的条件:

#include<stdio.h> 
int main(){
int arr [3][4] ;;
int i = 0;
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            scanf("%d", &arr[i][j]);
        }
     } 
	for(i=0;i<3;i++){//因为我们数组的行和列的角标是从0开始的;这里我们从行开始
        int j = 0;
        for(j=0;j<4;j++){//这里我们从列入手

            printf("%d", arr[i][j]);//打印这个数组
        }
       printf("\n");
     }
    return 0;
}

 

那么二维数组在创建以后,我所给他的数据元素的个数并没有到达我所定义的数组的数据元素的个数时,比如说一下情况:

int arr[3][4] = {{1,2},{2,3},{3,4}}

此时我可以很明显的发现我定义的二维数组的是一个三行四列的,但是我在初始话的时候,很明显给数组的行上的数据元素不够,那么这个数组害正确嘛?

那么在C语言中,如果说你所定义的数组的长度在你初始化的时候并没有给够它足够的数据元素的时候,那么此时计算机就会自己在你的数组后面给你补齐元素数据(用0补齐).

#include<stdio.h> 
int main(){
int arr [3][4] = {1,2,3,4,5,6,7};
	int i  = 0;
	for(i = 0 ;i < 3; i ++){
		int j = 0;
		for(j = 0; j < 4;j++){
			printf("%d",arr[i][j]);
		}
		printf("\n");
	}
    return 0;
}

 

输出的结果就是:          

 那么我们定义了一个数组,我们怎么来调用数组中的元素呢?

其实我们在调用数组中的元素的时候是通过数组元素的角标来访问数组元素的.

数组的行/列	0	1	2	3
0	1	2	3	4
1	5	6	7	8
2	9	10	11	12

上面我们初始化了一个数组:如果我们要访问数组中的某一个数据元素时,我们可以通过元素的下标了查询数据元素,比如说:我们要查询的是第2行第3列的元素:也就是我们的7,那么我们此时可以访问

arr[1][2]

那么为什么我在访问的时候,输入的是arr[1][2]不是arr[2][3]呢?那么在数组中,数组元素的下角标是从0开始的,行与列都是从0开始.

数组越界:数组角标是从0开始,最后一个元素是n-1,访问的数组的元素的角标的数字大于数组角标的最大值或者小于最小值,就出现了角标的越界. 角标越界的时候有时编译器不会报错.(C语言不做数组角标越界的检查,需要本人自己检查)

那么我们在访问二维数组的时候出现了这样的数组角标越界呢

arr [2][3] = {1,2,3,4,5,6}//我定义一个两行三列的数组,那么我此时在访问的时候不小心写错了
printf("%d",arr[0][3]);//此时我访问的数据元素是数组的第一行第四列的元素

那么此时我所访问的数据元素很明显出现了越界的情况,那么此时还会访问到元素嘛?在这就需要给大家说明一下二维数组在内存储空间中的位置.

在内存储空间中,二维数组是连续存储的,当我们访问的位置超出了第一行的角标的时候,此时就会直接越界到第二行去查找第一行后面的元素,也就是说,我们刚刚查找的数据元素是可以打印出来的,第一行第四列的元素并没有,但是会访问到第二行的第一列的元素,所以我们上面的代码是可以访问到数据元素的,它的输出值就是4,那么此时出现了数组的角标越界,那么程序仍然可以执行并且不会报错,所以以后在写代码的时候需要自己多注意这些细节,避免出现数组角标越界的情况.

 数组作为函数参数:数组在传参的时候只需要加上数组名 ,在这作为传参的时候,就不得不拿出我们的一个排序算法来给大家举例子了.

 注意:  在函数内部传数组时,其实传过去的是一个指针,如果说需要传过去数组的大小的时候,我们可以在函数外面传数组的长度,这样就可以防止传进去的指针不等于数组的长度从而出现排序中的错误.

 在函数外部传数组的长度值:

#include<stdio.h>
void paixu(int arr[],int size) {
	int i = 0; 
	for (i = 0; i < size; i++) {
		int j = 0;
		for (j = 0; j < size- i-1 ; j++) {
			if (arr[j] < arr[j+1]) {
				int tep = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = tep;
			}
		}
	}
}
int main() {
	int arr[] = {1,2,3,4,5,6};//我们定义一个数组 
	int size = sizeof(arr) / sizeof(arr[0]);
	paixu(arr,size);
	int i = 0;
	for (i = 0; i < size; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

此时我们发现这样的一个冒泡排序就可以正常的排序

那我们在函数内部传数组的长度:

#include<stdio.h>
void paixu(int arr[]) {
	int i = 0;
	int size = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < size; i++) {
		int j = 0;
		for (j = 0; j < size - i - 1; j++) {
			if (arr[j] < arr[j + 1]) {
				int tep = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = tep;
			}
		}
	}
}
int main() {
	int arr[] = { 1,2,3,4,5,6 };//我们定义一个数组 
	int size = sizeof(arr) / sizeof(arr[0]);
	paixu(arr);
	int i = 0;
	for (i = 0; i < size; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}

此时我们们发现,在函数的里面传送数组的长度的时候,并没有排序

 这在我们给大家输出一下此时的size的值

void paixu(int arr[]) {
	int i = 0;
	int size = sizeof(arr) / sizeof(arr[0]);

 此时输出的size的值是1,说明我们在函数的内部传进去以后,我们只循环了一次,说明我们的循环就没有执行.

 
 在函数内部传数组时,其实传过去的是一个指针,如果说需要传过去数组的大小的时候,我们可以在函数外面传数组的长度,这样就可以防止传进去的指针不等于数组的长度从而出现排序中的错误. 什么意思呢?就是我们在上面的排序的函数中传过去的数组,它并不是真正的数组,而是指针的变量.,在这里要给大家说明一下,数组的名字它本质上是这个数组首元素的地址.下面给大家来演示一下:

int main() {
	int arr[] = {1,2,3,4,5,6};//我们定义一个数组 
	printf("%d", arr);
	return 0;
}

 

 此时我们看,我输出的数组的名,它并没有输出整个数组的值,而是输出了一串数字,那么这个数字就是这个数组首元素在内存储空间的一个位置.

数组名是什么?:数组名能表示首元素的地址,但是有两个例外.
 1.sizeof(数组名):计算整个数组的大小 单位是字节 
 2.&数组名,数组名表示的是整个数组,表示的是整个数组的地址
 整个数组的地址+1表示的是地址是数组的最后的一个元素的后一位的地址.
 int n = sizeof(arr);//打印出n是?

#include<stdio.h>

int main() {
	int arr[] = { 1,2,3,4,5,6 };//我们定义一个数组 
	int n = sizeof(arr);
	printf("%d", n);
	return 0;
}

 

 此时输出的n的值是24,它输出的整个数组的一个长度,它里面有6个元素,每个元素占用4个比特位,

 二维数组名的理解:二维数组的数组名也表示数组首元素的地址,表示的是二维数组的第一行的元素的地址.(将二维数组看成一维数组)

int main() {
	int arr[3][2] = { 1,2,3,4,5,6 };//我们定义一个数组 
	printf("%p", arr);
	printf("\n");
	printf("%p", arr[0]);
	return 0;
}

 

发现数组名所表示的和数组首元素的地址是一样的.所以说二维数组的数组名也表示数组首元素的地址.
 arr 和arr+1相差的地址是一行的元素的距离.

int main() {
	int arr[3][2] = { 1,2,3,4,5,6 };//我们定义一个数组 
	printf("%p\n", arr);
	printf("%p\n", arr + 1);
	printf("----------------\n");
	printf("%p\n", arr[0]);
	printf("%p\n", arr[0]+1);
	return 0;
}

 我们看到给数组名+1的时候,输出的值相差了8,给数组首元素的地址+1的时候发现增加了4,那么在二维数组中,如果说是给二维数组名的地址+1的时候,此时地址相差了一行数据的位数,上述代码中也就是两个数据元素8个比特位.(&arr 取得是整个二维数组的地址.)

数组的长度:sizeof(arr)/sizeof(arr[0])//表示的是数组的元素的个数,在这为什么要除以呢,因为sizeof(数组名)表示的是整个数组中的所有数据元素所占的内存空间,它除以其中的一个数据元素的存储空间就是整个数组的长度,在这大家要注意,不要混淆.下面代码给大家解释一下;

#include<stdio.h>

int main() {
	int arr[]= { 1,2,3,4,5,6 };//我们定义一个数组 
	int i = sizeof(arr);
	printf("%d\n", i);
	int j = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", j);
	return 0;
}

本次的分享就到这结束了!期待我们下期再见.

 

 

1. 一维数组的创建和初始化

1.1 数组的创建

数组是一组相同类型元素的集合。
数组的创建方式：

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

数组创建的实例：

//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建？
//代码3
char arr3[10];
float arr4[1];
double arr5[20];

注：数组创建， [] 中要给一个常量才可以，不能使用变量。

1.2 数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
看代码：

int arr6[];//全局默认初始值为0
int main()
{
	//初始化
	int arr1[20] = { 1,2,3 };//不完全初始化，剩余的默认初始化为0
	int arr2[] = { 1,2,3 };
	char arr3[] = "abc";
	char arr4[] = { 'a','b','c'};
	char arr5[] = { 'a',98,'c' };

	return 0;
}
}

1.3 一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。我们来看代码：

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	//计算数组元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

1.4 一维数组在内存中的存储

打印数组元素地址：

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	//计算数组元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%p\n", &arr[i]);
	}
	return 0;
}

数组随着下标增长，地址由低到高变化。可以看出相邻地址相差4，且连续，说明一维数组在内存中连续存储。

2. 二维数组的创建和初始化

2.1 二维数组的创建

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

2.2 二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

int main()
{
	int arr1[3][5] = { 1,2,3,4,5,6,7,8,9,10,11 };
	int arr2[3][5] = { {1,2},{3,4},{4,5} };
	int arr3[][5] = { {1,2},{3,4},{4,5} };//初始化之后行数可以省略，
											//行数根据初始化来确定，但是列不能省略     
	char ch1[4][6] = { 'a','b' };
	char ch2[4][6] = { {'a'},{'b'} };
	char ch3[4][6] = { "abc","def","qwe" };
	
	return 0;
}

2.3 二维数组的使用

二维数组的使用也是通过下标的方式。

#include<stdio.h>
int main()
{
	int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,10} };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

2.4 二维数组在内存中的存储

像一维数组一样，这里我们尝试打印二维数组的每个元素。

int main()
{
	int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,10} };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("&arr[%d][%d] = %p\n", i,j,&arr[i][j]);
		}
		printf("\n");
	}
	}

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

二维数组的行可以省略，但是列不能省略，二维数组也可以看成一维数组

int main()
{
	int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,10} };
	int* p = &arr[0][0];
	int i = 0;
	for (i = 0; i < 15; i++)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

3. 数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int i = 0;
	for (i = 0; i <= 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序（这里要讲算法思想）函数将一个整形数组排序。
那我们将会这样使用该函数：

4.1冒泡排序：两两相邻的元素进行比较

void Sort(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i <sz-1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 34,45,7,8,23,45,89,900,100 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//数组名传递给函数会降级成首元素地址
	Sort(arr, sz);
	int i = 0;
	for (i = 0; i <= sz - 1; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4.2什么是数组名

//数组名就是首元素地址
//有两个例外
//1.当sizeof(数组名),数组名是整个数组
//2.&数组名，数组名是整个数组，取出的数组的地址

int main()
{
	int arr[10] = { 34,45,7,8,23};
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr);
	printf("--------------------------------\n");
	printf("%p\n", arr+1);
	printf("%p\n", &arr[0]+1);
	printf("%p\n", &arr+1);
	return 0;
}