精华内容
下载资源
问答
  • 主要介绍了JavaScrip学习笔记之数组基本操作,结合实例形式分析了javascript数组的基本定义、添加、删除、修改、连接、排序等操作技巧,需要的朋友可以参考下
  • PHP 还提供了超过 70 个内建函数来操作数组。 创建数组 使用 array() 语言结构创建数组: <?php $arr_age1 = array(18, 20, 25); // 或者: $arr_age2 = array("wang"=>18, "li"=>20, "zhang"=>25); // 空数组...
  • 二维数组基本操作的编程实现 二、题目要求 二维数组基本操作的编程实现,掌握数组的建立、读取数据、压缩存储等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。也鼓励学生利用基本...

    一、实验题目

    二维数组基本操作的编程实现

    二、题目要求

    二维数组基本操作的编程实现,掌握数组的建立、读取数据、压缩存储等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。也鼓励学生利用基本操作进行一些应用的程序设计。

    三、运行结果

    在这里插入图片描述
    在这里插入图片描述

    四、程序基本功能

    1、矩阵生成

    对于矩阵的生成,我采用了两种方式,第一种为随机生成,第二种为文件导入,其实之前我打算加入第三种人工输入的,我认为文件导入其实就包括了人工输入,所以放弃了这种方法。

    (1)随机生成矩阵

    函数名:arraycreate1()
    描述:随机生成一个1x1—20x20的矩阵,并且非零元大约为总数的20%。
    入口参数:无
    出口参数:无
    说明:函数执行之后,我首先随机生成了随机行row和随机列col,然后确定存储随机矩阵大小的二维数组,接着控制非零元的个数count在总数的20%左右。然后初始化row*col二维数组全为0,通过一个for循环随机生成一个数据,该数据的十位存为行rowc,该数据的个位存为列colc,然后为二维数组array[rowc][colc]随机赋值。部分重要代码如下:

    	row=rand()%20+1;
    	col=rand()%20+1;
    	int data[row*col/5];
    	do
    	{
    		srand(time(NULL)); //避免每次产生相同的随机数
    		if(row*col/5==0)   //行数*列数<5
    		{
    			count=1;
    		}
    		else
    		count=rand()%(row*col/5); //非零数的个数 
    	}while(count<(row*col/5-3)); 
    	for(i=0;i<row;i++)
    	for(j=0;j<col;j++)
    	{
    		array[i][j]=0;		//数组初始化为0 
    	}
    	for(i=0;i<count;i++)	//随机为count个数赋值 
    	{
    		data[i]=rand()%100;
    		rowc=data[i]/10;
    		colc=data[i]%10;
    		do
    		{
    			array[rowc][colc]=rand()%100;	
    		}while(array[rowc][colc]<10);
    	}
    	printf("随机%dx%d矩阵已生成!\n",row,col);
    

    (2)文件导入矩阵

    函数名:arraycreate2()
    描述:从文件导入一个1x1—20x20的矩阵。
    入口参数:无
    出口参数:无
    说明:首先在“文件导入矩阵数据.txt”文件中输入符合规格的矩阵。先判断此文件是否存在,不存在即退出,否则开始读取数据,进入while循环,当文件读取结束时结束循环。While循环中读入字符ch,判断字符ch是否是空格或者回车,如果是空格j++,如果是回车i++。用i,j最终的值确定文件中的行列数。再次读取文件,确定行列数之后,用fscanf()函数读取数据,录入所在的行列。最后关闭文件。部分重要代码如下:

    	if((fp=fopen("文件导入矩阵数据.txt","r"))==NULL)
    	{
    		printf("文件打开失败!\n");
    		exit(0);
    	}
        while (!feof(fp))       
    	{ 
    		ch=fgetc(fp);
    	    if(ch==' ')  
    		{
        		j++;
        		continue;
    		}
    	    if(ch=='\n')
    		{
    	    	i++;
    	     	continue;
    		}
    	}
    	row=i+1;
    	col=j/(i+1);
    	fp=fopen("文件导入矩阵数据.txt", "r");
    	for(i=0;i<row;i++)
    	for(j=0;j<col;j++)
    	{
    		fscanf(fp,"%d",&array[i][j]);
    	}
    	printf("\n矩阵导入完成!\n");
    	fclose(fp);
    

    文件导入矩阵数据.txt

     1 1 1 0 0
     2 2 2 0 0
     3 3 3 0 0
     4 4 4 0 0
    

    (3)矩阵压缩三元组

    函数名:arraycompress()
    描述:将矩阵中的非零元压缩成三元组。
    入口参数:无
    出口参数:无
    说明:由于行row,列col均是全局变量,所以开始定义一个rowcol大小的结构体数组(struct compress data[rowcol]),通过两个for循环判断当array[i][j]==0时将i赋值给data[count+1].row,将j赋值给data[count+1].col,array[i][j]赋值给data[count+1].number。每添加一组数据count++。然后把行row,列col,count赋值给data[0],即矩阵压缩三元组成功。部分重要代码如下:

    	for(i=0;i<row;i++)
    	{
    		for(j=0;j<col;j++)
    		{
    			if(array[i][j]!=0)
    			{
    			data[count+1].row=i;
    			data[count+1].col=j;
    			data[count+1].number=array[i][j];
    			count++;
    			}
    		}
    	}
    	data[0].row=row;
    	data[0].col=col;
    	data[0].number=count;
    

    2、三元组生成

    三元组生成有两种方式,随机生成三元组和文件导入三元组.

    (1)随机生成三元组

    函数名:groupcreate1()
    描述: 随机生成一个三元组
    入口参数:无
    出口参数:无
    说明:首先随机生成矩阵的行row,列col,和非零元的个数count,并且非零元的个数限制在总数的20%,将行、非零元的个数存在data[0]中。然后定义一个value[count+1],随机生成count个0- -(row-1)*(col-1)大小的数,为了让三元组中数据是有序的,通过冒泡法将value这个一维数组中我的数据排序,之后将每个数的十位作为该组数据的行,个位数作为列,之中判断该行该列是否重复,通过一个判断重复函数来判断,然后随机为该行该列的非零元随机赋值。部分重要代码如下:

    	row=rand()%10+1;
    	col=rand()%10+1;
    	count=rand()%((row*col+1)/5);
    	int value[count+1];
    	struct compress data[count+1];
    	data[0].row=row;
    	data[0].col=col;
    	data[0].number=count;
    	for(i=0;i<count;i++)
    	{	
    		value[i]=rand()%((row-1)*(col-1)-9)+1;
    	}
    	groupsort(count,value); //三元组排序
    	for(i=1;i<=count;i++)
    	{
    		do
    		{
    			data[i].row=value[i-1]/10;
    			data[i].col=value[i-1]%10;
    		}while(testrepeat(i,data));	//判断是否重复
    		data[i].number=rand()%100;
    	}
    	printf("随机三元组已生成!\n");
    

    (2)文件生成三元组

    函数名:groupcreate2()
    描述: 通过文件导入一个三元组
    入口参数:无
    出口参数:无
    说明:文件导入还存在Bug
    在这里插入图片描述

    (3)三元组解压为矩阵

    函数名:groupcreate2()
    描述: 把三元组解压为矩阵
    入口参数:无
    出口参数:无
    说明:因为我是把这个函数插入在生成三元组中,所以矩阵的行列数已经知道,首先直接通过两个for循环对矩阵初始化为0,然后再通过两个for循环把三元组中的数据赋值给矩阵中所在的位置。部分重要代码如下:

    	for(i=0;i<row;i++)
    	for(j=0;j<col;j++)  //矩阵初始化为0
    	{
    		array[i][j]=0;
    	}
    	for(i=1;i<=count;i++)
    	{
    		do
    		{
    			data[i].row=value[i-1]/10;
    			data[i].col=value[i-1]%10;
    		}while(testrepeat(i,data));	
    		data[i].number=rand()%100;
    		array[data[i].row][data[i].col]=data[i].number; //赋值
    	}
    	printf("随机三元组已生成!\n");
    	for(i=0;i<=count;i++)
    	{
    		printf(" %d %d %d\n",data[i].row,data[i].col,data[i].number);
    		fprintf(fp," %d %d %d\n",data[i].row,data[i].col,data[i].number);
    	}
    	printf("\n三元组解压矩阵成功!\n");
    

    五、源码

    #include<stdio.h>
    #include<windows.h>
    #include<stdlib.h>
    #include<time.h>
    #define max 30
    void showmenu();//菜单显示
    void processmenu();//菜单控制
    void arraycreate(); //矩阵生成
    void arraycreate1();//随机生成矩阵
    void arraycreate2();//文件导入矩阵
    void groupcreate(); //三元组生成
    void groupcreate1();//随机生成三元组
    void groupcreate2();//文件导入三元组
    void arraycompress(); //矩阵压缩
    void showarray();  //显示矩阵
    int testrepeat(int k,struct compress *p); //判断三元组是否重复
    int groupsort(int k,int *p);   //三元组排序
    int array[max][max];//矩阵
    int row=0,col=0; //矩阵行,列
    struct compress {
    	int row; //行
    	int col; //列
    	int number; //数据
    };
    int main() {
    	system("color f0");//背景白色
    	while(1) {
    		showmenu();
    		processmenu();
    		system("pause");
    		system("cls");
    	}
    }
    void showmenu() {
    	puts("~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("\t  二维数组基本操作的编程实现");
    	puts("\t\t操作软件:dev c++");
    	puts("~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("~~~\t\t1、矩阵输入\t\t~~~~");
    	puts("~~~\t\t2、三元组输入\t\t~~~~");
    	puts("~~~\t\t0、退出程序\t\t~~~~");
    	puts("~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("");
    	printf("请输入您的选择:");
    }
    void processmenu() {
    	int menuchoice;//菜单选择
    	scanf("%d",&menuchoice);
    	switch(menuchoice) {
    		case 1:
    			arraycreate();//矩阵生成
    			break;
    		case 2:
    			groupcreate(); //三元组生成
    			break;
    		case 0:
    			puts("\n~~~~~~~~~~~~~~~~~~~~~~~~");
    			puts("\t\t欢迎下次再用!");
    			puts("~~~~~~~~~~~~~~~~~~~~~~~~\n");
    			exit(0);
    		default :
    			printf("输入错误!请重新输入...\n");
    	}
    }
    void arraycreate() {	//矩阵生成
    	int choose;
    	printf("  1、随机生成\n");
    	printf("  2、文件导入\n");
    	printf("请选择输入方式:");
    	scanf("%d",&choose);
    	switch(choose) {
    		case 1:
    			arraycreate1(); //随机生成矩阵
    			break;
    		case 2:
    			arraycreate2(); //文件导入矩阵
    			break;
    		default :
    			printf("输入错误!\n");
    	}
    	showarray(); //显示矩阵
    	arraycompress(); //压缩矩阵为三元组
    }
    void arraycreate1() { //随机生成矩阵
    	int i,j;
    	int count;
    	int rowc,colc;
    	row=rand()%20+1;
    	col=rand()%20+1;
    	int data[row*col/5];
    	do {
    		srand(time(NULL));
    		if(row*col/5==0) {
    			count=1;
    		} else
    			count=rand()%(row*col/5); //非零数的个数
    	} while(count<(row*col/5-3));
    	for(i=0; i<row; i++)
    		for(j=0; j<col; j++) {
    			array[i][j]=0;		//数组初始化为0
    		}
    	for(i=0; i<count; i++) {	//随机为count个数赋值
    		data[i]=rand()%100;
    		rowc=data[i]/10;
    		colc=data[i]%10;
    		do {
    			array[rowc][colc]=rand()%100;
    		} while(array[rowc][colc]<10);
    	}
    	printf("随机%dx%d矩阵已生成!\n",row,col);
    }
    void arraycreate2() { //文件导入矩阵
    	FILE *fp;
    	char ch;
    	int i=0,j=0;
    	if((fp=fopen("文件导入矩阵数据.txt","r"))==NULL) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	while (!feof(fp)) {
    		ch=fgetc(fp);
    		if(ch==' ') {
    			j++;
    			continue;
    		}
    		if(ch=='\n') {
    			i++;
    			continue;
    		}
    	}
    	row=i+1;
    	col=j/(i+1);
    	fp=fopen("文件导入矩阵数据.txt", "r");
    	for(i=0; i<row; i++)
    		for(j=0; j<col; j++) {
    			fscanf(fp,"%d",&array[i][j]);
    		}
    	printf("\n矩阵导入完成!\n");
    	fclose(fp);
    }
    void showarray() { //显示矩阵
    	FILE *fp;
    	if((fp=fopen("矩阵显示后数据.txt","w"))==NULL) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	int i,j;
    	for(i=0; i<row; i++) {
    		for(j=0; j<col; j++) {
    			printf("[%d]",array[i][j]);
    			fprintf(fp," %d",array[i][j]);
    		}
    		if(i==row-1)
    			break;
    		else {
    			printf("\n");
    			fprintf(fp,"\n");
    		}
    	}
    	printf("\n");
    	fclose(fp);
    }
    void arraycompress() { //矩阵压缩
    	int i,j;
    	int count=0;
    	struct compress data[row*col];
    	FILE *fp;
    	if((fp=fopen("矩阵压缩后三元组数据.txt","w"))==NULL) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	for(i=0; i<row; i++) {
    		for(j=0; j<col; j++) {
    			if(array[i][j]!=0) {
    				data[count+1].row=i;
    				data[count+1].col=j;
    				data[count+1].number=array[i][j];
    				count++;
    			}
    		}
    	}
    	data[0].row=row;
    	data[0].col=col;
    	data[0].number=count;
    	printf("\n矩阵压缩三元组成功!\n");
    	printf("r c v\n");
    	for(i=0; i<=count; i++) {
    		printf("%d %d %d \n",data[i].row,data[i].col,data[i].number);
    		fprintf(fp,"%d %d %d \n",data[i].row,data[i].col,data[i].number);
    	}
    	fclose(fp);
    }
    void groupcreate() { //三元组生成
    	int choose;
    	printf("  1、随机生成\n");
    	printf("  2、文件导入\n");
    	printf("请选择输入方式:");
    	scanf("%d",&choose);
    	switch(choose) {
    		case 1:
    			groupcreate1(); //随机生成三元组
    			break;
    		case 2:
    			groupcreate2(); //文件导入三元组
    			break;
    		default :
    			printf("输入错误!\n");
    	}
    }
    void groupcreate1() { //随机生成三元组
    	FILE *fp;
    	if((fp=fopen("随机生成三元组数据.txt","w"))==NULL) {
    		printf("文件读取失败!\n");
    		exit(0);
    	}
    	int i,j;
    	int count;
    	srand(time(NULL));
    	row=rand()%10+1;
    	col=rand()%10+1;
    	count=rand()%((row*col+1)/5);
    	int value[count+1];
    	struct compress data[count+1];
    	data[0].row=row;
    	data[0].col=col;
    	data[0].number=count;
    
    	for(i=0; i<count; i++) {
    		value[i]=rand()%((row-1)*(col-1)-9)+1;
    	}
    
    	groupsort(count,value); //三元组排序
    	for(i=0; i<row; i++)
    		for(j=0; j<col; j++) {
    			array[i][j]=0;
    		}
    	for(i=1; i<=count; i++) {
    		do {
    			data[i].row=value[i-1]/10;
    			data[i].col=value[i-1]%10;
    		} while(testrepeat(i,data));
    
    		data[i].number=rand()%100;
    		array[data[i].row][data[i].col]=data[i].number;
    	}
    	printf("随机三元组已生成!\n");
    	for(i=0; i<=count; i++) {
    		printf(" %d %d %d\n",data[i].row,data[i].col,data[i].number);
    		fprintf(fp," %d %d %d\n",data[i].row,data[i].col,data[i].number);
    	}
    	printf("\n三元组解压矩阵成功!\n");
    	fclose(fp);
    	showarray();
    }
    void groupcreate2() { //文件导入三元组
    	FILE *fp;
    	if((fp=fopen("文件导入三元组数据.txt","r"))==NULL) {
    		printf("文件读取失败!\n");
    		exit(0);
    	}
    	int ch;
    	int i,j;
    	int rowc=0;
    	while(!feof(fp)) {
    		ch=fgetc(fp);
    		if(ch==' ') {
    			j++;
    			continue;
    		}
    		if(ch=='\n') {
    			i++;
    			continue;
    		}
    	}
    	rowc=i+1;
    	struct compress data[rowc];
    	fp=fopen("文件导入三元组数据.txt","r");
    	for(i=0; i<rowc; i++) {
    		fscanf(fp,"%d",&data[i].row);
    		fscanf(fp,"%d",&data[i].col);
    		fscanf(fp,"%d",&data[i].number);
    		array[data[i].row][data[i].col]=data[i].number;
    	}
    
    	printf("文件三元组已生成!\n");
    
    	for(i=0; i<rowc; i++) {
    		printf(" %d %d %d\n",data[i].row,data[i].col,data[i].number);
    		fprintf(fp," %d %d %d\n",data[i].row,data[i].col,data[i].number);
    	}
    	printf("\n三元组解压矩阵成功!\n");
    	fclose(fp);
    	showarray();
    }
    int testrepeat(int k,struct compress *p) { //判断三元组是否重复
    	for(int i=0; i<k; i++)
    		if(p[k].row==p[i].row&&p[k].col==p[i].col)
    			return 1;
    	return 0;
    }
    int groupsort(int k,int *p) { //三元组排序
    	int min;
    	for(int i=0; i<k; i++) {
    		for(int j=i+1; j<k; j++) {
    			if(p[j]<p[i]) {
    				min=p[j];
    				p[j]=p[i];
    				p[i]=min;
    			}
    		}
    	}
    }
    
    展开全文
  • 下面小编就为大家带来一篇PHP 数组基本操作小结(推荐)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JS数组基本操作

    千次阅读 2019-04-22 21:12:26
    ES6: fill() 填充数组 参数: 第一个元素(必须): 要填充数组的值 第二个元素(可选): 填充的开始位置,默认值为0 第三个元素(可选):填充的结束位置,默认是为this.length 删 pop(): 删除末尾的元素 shift():删除...

    创建

    var a = [1,2,3]
    var a = Array()

    push():在末尾增加一个元素
    unshift():在首部增加一个元素

    ES6: fill() 填充数组
    参数:
    第一个元素(必须): 要填充数组的值
    第二个元素(可选): 填充的开始位置,默认值为0
    第三个元素(可选):填充的结束位置,默认是为this.length

    pop(): 删除末尾的元素
    shift():删除第一个元素
    delete:删除指定元素,但是数组长度

    一个方法实现增删

    splice()

    • index:必需。整数,规定添加/删除项目的位置,使用负数可从数组结尾处规定位置。
    • howmany:必需。要删除的项目数量。如果设置为 0,则不会删除项目。
    • item1, …, itemX: 可选。向数组添加的新项目。

    indexOf(): 查找数组是否存在某个元素,返回下标
    lastIndexOf() :查找指定元素在数组中的最后一个位置
    includes() :查找数组是否包含某个元素 返回布尔
    find() :用于找出第一个符合条件的数组成员

    遍历

    1.forEach():
    array.forEach(function(currentValue, index, arr), thisValue)

    1. currentValue(必须),数组当前元素的值
    2. index(可选), 当前元素的索引值
    3. arr(可选),数组对象本身
    • 无法中途退出循环,只能用return退出本次回调,进行下一次回调。
    • 它总是返回 undefined值,即使你return了一个值。
    1. ES6 提供三个新的方法——entries(),keys()和values()——用于遍历数组。
      keys()是对键名的遍历、values()是对键值的遍历,entries()是对键值对的遍历。
    for (let index of ['a', 'b'].keys()) {
      console.log(index);
    }
    // 0
    // 1
    
    
    for (let elem of ['a', 'b'].values()) {
      console.log(elem);
    }
    // 'a'
    // 'b'
    
    for (let [index, elem] of ['a', 'b'].entries()) {
      console.log(index, elem);
    }
    // 0 "a"
    // 1 "b"
    

    排序

    sort()
    sort要正确排序必须配合一个排序函数

    function arrySort(a,b) {
    return a-b
    }
    

    颠倒顺序

    reserse()
    返回值为undefind

    合并

    1.[…arr1, …arr2, …arr3]
    2.concat()

    数组转字符串

    1.join():用指定分隔符分割连接

    let a= ['hello','world'];
    let str=a.join(); // 'hello,world'
    let str2=a.join('+'); // 'hello+world'
    

    2.toString() 和join相同但是不能指定分隔符

    字符串转数组

    split()方法与join()方法正好相反
    它有两个参数:

    • separator 必需。字符串或正则表达式,从该参数指定的地方分割 stringObject。
    • howmany 可选。该参数可指定返回的数组的最大长度。如果设置了该参数,返回的子串不会多于这个参数指定的数组。如果没有设置该参数,整个字符串都会被分割,不考虑它的长度。
      如果用 “” 中间没有分号,作为分隔符,每个字符都会被分割开

    数组拷贝

    1.const a2 = […a1];

    2.深拷贝

    • 利用concat
    let arr = [1,2,3];
    let arr2 = [].concat(arr);
    
    • 利用JSON深拷贝
    let obj = {
    a:1,
    b:2,
    c:undefind,
    fun:function () {
    console.log("function")
    }
    };
    let obj2 = JSON.parse(JOSN.Stringify(obj));
    console.log(obj2);
    //object:[a:1,b:2]
    //用JSON拷贝会忽略undefined和function
    

    数组降维

    flat() 方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
    flat(1) 表示拉平一层,Infinity关键字可以将所有层拉平

    filter()方法

    filter方法可以实现数组的筛选

    filter有三个参数:
    element:数组中的元素
    index:参数位置
    array:数组本身

    用法:

    var a = [1,2,2, ,3,4,4,5];
    // 只写一个参数则时element
    var b = a.filter(function (num) {
    	return num && num.trim();	//trim()会去除字符串两端的空格
    })
    //最后会得到去除空格的字符串
    
    var c = a.filter(function (num,index,array){
    	return array.indexOf(num) === index;
    })
    //	这样就可以巧妙的去除重复元素,原理是indexOf会返回元素第一次出现的位置,和index进行比较就可以得出是不是重复的
    

    ES6的set数组去重方法

    结果是返回一个新数组

     let array = [1, 1, 1, 1, 2, 3, 4, 4, 5, 3];
     let set = new Set(array);
     console.log(set);
     // => Set {1, 2, 3, 4, 5}
    
    展开全文
  • python数组基本操作总结

    万次阅读 多人点赞 2018-06-19 18:26:42
     (5)操作符:   Python 表达式 结果 描述 len([1, 2, 3]) 3 长度 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合 ['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复 3 in [1, 2, 3] True 元素是否存在于列表中 ...

    一.列表,元祖,:

        1.元祖:

            (1)创建:

                    tuple01 = ()#创建空元组

                        tuple01 = (2,) #元组中只包含一个元素时,需要在元素后面添加逗号

                    tuple01 = ('joe','susan','black','monika')

            (2)将元组转换为列表:

                tup01 = list(tuple01)  

            (3)查看:

                tuple01[0:2]   #0-1的元素 的切片,  返回 ('joe','susan')

                tuple01[ 0 ]  #返回  'joe'

                tuple01[ -2] #反向取第二个元素, 'black'

                tuple01[ 1:]  #从第二个到最后一个的切片 

                tuple01[0:10:3] #从0到9,步长为3.,取0,3,6,9

                 tuple01[::3] #从头到为尾,步长为3

            (4)元组中的元素值是不允许修改的,禁止删除或添加元素,可以del删除整个元祖

            (5)连接:

                t = (1,2,3)+(4,5,6) #(1,2,3,4,5,6)

                #可以使用切片再连接的方式修改元祖元素;或转化为列表

              (6)内置函数:

                    len(t) #长度

                    max(t)#返回最大元素

                    min(t)

              (7)复制:

                   tuple01*2   #所有元素复制两倍

              (8)元素是否存在:

                    2  in  tuple01  #返回bool

                (9)迭代:

                    for  x  in  tuple01 : print(x)

            2.列表:

                (1)创建:

                    list = [1,2,3,4]

                (2)参考元祖(2)

                (3)添加:

                    list.append(3)

                (4)删除:

                    del list[1]

                (5)操作符:

                    

    Python 表达式结果描述
    len([1, 2, 3])3长度
    [1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合
    ['Hi!'] * 4['Hi!', 'Hi!', 'Hi!', 'Hi!']重复
    3 in [1, 2, 3]True元素是否存在于列表中
    for x in [1, 2, 3]: print x,1 2 3迭代

           (6)转化为元祖:

                    tuple([1,2,3])

                (7)函数:

    序号方法
    1list.append(obj)
    在列表末尾添加新的对象
    2list.count(obj)
    统计某个元素在列表中出现的次数
    3list.extend(seq)
    在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    4list.index(obj)
    从列表中找出某个值第一个匹配项的索引位置
    5list.insert(index, obj)
    将对象插入列表
    6list.pop([index=-1])
    移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    7list.remove(obj)
    移除列表中某个值的第一个匹配项
    8list.reverse()
    反向列表中元素
    9list.sort(cmp=None, key=None, reverse=False)
    对原列表进行排序

                (8)创建一个有规律的二维列表      

    [[0 for col in range(cols)] for row in range(rows)]

                 (9)

                    [x  for x in arr if x>5 ]  #筛选

                    [x if x>5 else x+100 for x in arr ]

                    [x if z else y for x,y,z in zip(arr1,arr2,condition)]  #和np.where函数一样的功能;

            

            3.字典:

                (1)创建:

                     dict01 = {'name1':'joe','name2':'suan','name3':'anne'}

                    #不可变类型可以做字典的下标,可变类型不可以,下标不能是列表

                (2)访问:

                    dict01['name']

                (3)修改或添加:

                    dict01['address'] = '泰国'

                    #同一个键不能出现两次,否则后者覆盖前者;

                (4)删除:

                    del dict01['sex']

                (5)方法:

    Python字典包含了以下内置函数:

    序号函数及描述
    1cmp(dict1, dict2)
    比较两个字典元素。
    2len(dict)
    计算字典元素个数,即键的总数。
    3str(dict)
    输出字典可打印的字符串表示。
    4type(variable)
    返回输入的变量类型,如果变量是字典就返回字典类型。

    Python字典包含了以下内置方法:

    序号函数及描述
    1dict.clear()
    删除字典内所有元素
    2dict.copy()
    返回一个字典的浅复制
    3dict.fromkeys(seq[, val])
    创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
    4dict.get(key, default=None)
    返回指定键的值,如果值不在字典中返回default值
    5dict.has_key(key)
    如果键在字典dict里返回true,否则返回false
    6dict.items()
    以列表返回可遍历的(键, 值) 元组数组
    7dict.keys()
    以列表返回一个字典所有的键
    8dict.setdefault(key, default=None)
    和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
    9dict.update(dict2)
    把字典dict2的键/值对更新到dict里
    10dict.values()
    以列表返回字典中的所有值
    11pop(key[,default])
    删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
    12popitem()
    随机返回并删除字典中的一对键和值。

                    

    二.numpy:

        1.numpy创建的数组类型为: numpy.ndarray

        2.创建方式:

        (1)array方法:

                np.array( [1,2,4,5,6] )

                np.array( [ [1,2,3] , [3,4,5] ] )  #2*3二维数组

                np.array( (1,2,3) )   #传入元祖

                np.array( ((1,2,3), (4,5,6) )) #2*3

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

        (2)zeros,ones,empty方法:

                zeros返回全0数组

                ones返回全1数组

                empty返回全0数组

                

                np.zeros( 6 )  #返回1*6

                np.zeros( (2,4) ) #传入元祖,返回2*4数组

                np.zeros( (2,4,5) )  #2*4*5

                # ones,empty方法使用方式类似

            

            (3)arange方法:

                np.arange(5)  #默认从0开始,到4的整数数组,默认步长为1

                np.array(1,5)   #从1开始到4

                np.array(1,10,3) #从1到9,步长为3

                np.array(10,3,-2) #从10到2,步长为2

                

            (4)linespace,logspace方法:

                   np.linespace(1,10,5) #从1到10的等差数列,5个数

                   np.logspace(1,2,5,base=10) #从10**1到10**2的等比数列,5个数,不设base默认以e为底

            

            (5)random模块:

                    np.random.random( (2,3) ) #传入元祖,2*3数组,元素是0-1随机浮点数,返回类型是列表;

                    np.random.rand(2,3) #不传元祖,元素是0-1随机浮点数,2*3,

                    np.random.randn( 2,3 ) #不传元祖 ,元素是服从标准正态分布的随机样本,大部分在[-2,2]之间,2*3

                    np.random.randint(1,10,(2,3)) #1到9之间的随机整数,2*3

            

            2.ndarray的属性:

                arr = np.array(np.random.randint(1,9,(2,3,4)))

                arr.ndim  #ndarray维度,3

                arr.shape #形状 (2,3,4)

                arr.size  #元素个数 ,24

                arr.itemsize #每个元素占字节数 ,4

                

                arr01 = np.array([1,2,3,4,5],dtype = np.float32)  #dtype 指定元素类型 有int,float32,float64,double多种类型

                arr02 = arr01.astype(np.int)   #修改元素类型

                arr02.dtype  #返回元素类型

            

               3.修改形状:

               (1)

                arr01 = np.random.randint(1,9,(3,4))

                arr04.shape = (4,3)   #先把3*4数组变成一维列表,再排成4*3数组;数组元素总数不变的;

                例:

                修改前:

                [[1, 5, 6, 3],
                [4, 4, 6, 4],
                [1, 1, 7, 6]]
             修改后:  
    
    
                [[1, 5, 6],
                [3, 4, 4],
                [6, 4, 1],
                [1, 7, 6]]

                   arr01.shape = (12)  # [1, 5, 6, 3, 4, 4, 6, 4, 1, 1, 7, 6]

                (2)reshape:

                    arr01.reshape(2,6)

                    降维操作:

                    arr01 = np.random.randint(1,9,(3,4,5))

                    arr07.reshape(5,-1)  #3*4*5维数组变成5*n;n=12

                (3)升维操作:

                        arr1 = np.random.randint(1,9,(2,2))
                        arr1[:,np.newaxis,:] #把2*2变成2*1*2


                 4.数组的运算:

                  (1)数组与标量的运算:

                    arr01+10
                    arr01-10
                    arr01*10
                    arr01/10
                    arr01**2

                    10**arr01  #每个数组元素与标量运算

                  (2)数组与数组的运算

                       arr02+arr03
                       arr02-arr03
                       arr02*arr03
                       arr02/arr03

                       arr02**arr03   #数组与数组形状一致

                        #特殊情况:

                           例:A:2*3*4  与 B:2*1*4可以运算,A的每个2*1*4与B运算;这样的要求就是B有一维是1,其他维和A一致;

                            或 A:2*3*4 与 B:3*4可以运算,A的每个3*4和B运算;但B:2*4则不能;要求B和A低的维度形状相同;

                

                (3)矩阵积:

                        arr01.dot(arr02)

               

                4.索引:

                (1)

                arr09 = np.random.randint(1,9,(3,3,4)) 

                

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

            

            arr09[:,:,:] #全部,和arr09一样

            arr09[1]   #第二个3*4数组;

            [[8 1 8 8]

          [6 1 6 2]
          [7 7 8 5]]


            arr09[:,1]  #3*4

            [[3 2 4 2]

          [6 1 6 2]
          [8 7 4 4]]
    
    

            arr09[:,:,1]  #3*3

            [[2 2 1]

          [1 1 7]
          [6 7 6]]
    
    

            arr09[0,0,0] 

            #  3

            (2)arr10[:,:] = 100  #直接修改arr10数组元素的值;

            (3)切片:

                arr11 = np.ones((2,6))  #

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

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

                arr11[:1]   #

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

              (4)花式索引:

                    arr12 = np.arange(32).reshape(8,4)

                    [[ 0, 1, 2, 3],

               [ 4,  5,  6,  7],
               [ 8,  9, 10, 11],
               [12, 13, 14, 15],
               [16, 17, 18, 19],
               [20, 21, 22, 23],
               [24, 25, 26, 27],
               [28, 29, 30, 31]]
    
    

                arr12[0,3] #标准索引,返回3

                arr12[ [0,3,5] ]  #返回第0,3,5行

                      [[ 0 1 2 3]

                 [12 13 14 15]
                 [20 21 22 23]]
                arr12[[0,3,5],[0,1,2]]  #返回第0行第0列,第3行第1列,第5行第2列的那个数组成的数组;

                    [ 0 13 22]

                arr12[np.ix_( [0,3,5] , [0,1,2] ) ]  #有索引器,返回3*3,第0行第0列,第3行第1列,第5行第2列
                    [[ 0, 1, 2],
               [12, 13, 14],
               [20, 21, 22]]
    
    

                (5)布尔索引:

                    第一种:

                    arr12 = np.random.randint(1,9,(3,4))

                    [[6, 6, 5, 6],

               [6, 1, 7, 7],
               [5, 1, 1, 8]]

                    arr12<5

                    [[False, False, False, False],

               [False,  True, False, False],
               [False,  True,  True, False]]

                    arr12[arr12<5] 

                    [1, 1, 1]

                    #索引(arr1<5)和 原数组形状相同,返回  一维            

                    第二种:

                    arr1[ [true,false,false] ]

                    [[6, 6, 5, 6]]

                    #注意:返回的二维数组;

                

                

                   5.常用的一元函数:

                    np.abs(arr)   #abs,fabs  计算整数、浮点数或者复数的绝对值,对于非复数,可以使用更快的fabs

                    np.sqrt(arr)    #计算各个元素的平方根

                    np.square(arr)  #计算各个元素的平方 

                    np.exp(arr)  #计算各个元素的指数e的x次方

                    np.log(arr)
                    np.log2(arr)

                    np.log1p(arr)  #分别计算自然对数、底数为2的log以及底数为e的log(1+x)

                    np.sign(arr)  #计算各个元素的正负号: 1 正数,0:零,-1:负数

                    np.ceil(arr)  #向上取整
                    np.floor(arr) #向下取整

                    np.rint(arr)  #四舍五入

                    

                    np.var( arr )  #求该arr方差 ,所有元素     

                

                6.ndarray的其他操作:

                (1)转置

                arr13.T   #矩阵转置操作

                #多维数组转置不常用,所以不讲了;

                

                   (2)拉伸:

                    arr = np.random.randint(1,9,(2,2))

                        [[5, 7],

                   [4, 1]]
    
    

                   np.tile(arr,3) #横向拉伸3次

                    [[5 7 5 7 5 7]

                 [4 1 4 1 4 1]]
    
    

                    np.tile(arr,(3,3)) #横向拉伸3次,纵向拉伸3次

                      [[5 7 5 7 5 7]

                 [4 1 4 1 4 1]
                 [5 7 5 7 5 7]
                 [4 1 4 1 4 1]
                 [5 7 5 7 5 7]
                 [4 1 4 1 4 1]]

                (3)聚合:

                    arr = np.random.randint(1,9,(2,3))

                    #arr可以调用的聚合函数有mean,sum,max,min,std,var,axis=1对每一列聚合,axis=0对每一行聚合

                    #std标准差

                    arr.mean(axis = 1) #1*3

                    arr.mean(axis = 0) #2*1

                

                 (4)where:

                    np.where([[True, False], [True, True]] , [[1, 2], [3, 4]] , [[9, 8], [7, 6]])   

                    #三个数组形状相同,第一个数组元素是true,选第二个数组元素,否则选第三个数组元素;

            

                   (5)去重:

                    np.unique(arr)

                    #去除重复元素,如果arr是多维的,返回一维的;


        三.dataFrame:

            dataFrame是比ndarray多了行标,列标的数组;

            创建方式为:

            import pandas as pd
            df = pd.DataFrame(index=[1,2,3],columns=[4,5,6])

            

            在机器学习算法中,ndarray比dataFrame好操作,所以:

                可以接收dataFrame类型,然后转化为dnarray类型:

                    df.values;






                      
    
    
    
    
    
    
    
    
          
    
    
    
            
    



    展开全文
  • 主要介绍了简单了解python数组基本操作,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java数组基本操作

    千次阅读 多人点赞 2018-02-21 13:47:32
    数组声明 数组初始化 遍历数组 Arraysfill填充数组 Arrayssort对数组排序 ArrayscopyOf复制数组 检查数组中是否包含某一个值 连接两个数组 数组翻转 从数组中移除一个元素 java打印数组 定位元素位置 ...

    数组声明

    数组声明有如下两种形式(方括号的位置不同):

    int arr[];
    int[] arr2;

    数组初始化

    数组初始化也有两种形式,如下(使用new或不使用new):

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

    遍历数组

    遍历数组可用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
      }
    }

    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();

    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();

    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();

    检查数组中是否包含某一个值

    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函数来判断元素是否包含在链表中。

    连接两个数组

    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方法可以很方便地将两个数组连接成一个数组。

    数组翻转

    int[] intArray = { 1, 2, 3, 4, 5 };
    ArrayUtils.reverse(intArray);
    System.out.println(Arrays.toString(intArray));
    //[5, 4, 3, 2, 1]

    依然用到了万能的ArrayUtils。

    从数组中移除一个元素

    int[] intArray = { 1, 2, 3, 4, 5 };
    int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
    System.out.println(Arrays.toString(removed));

    java打印数组

     Arrays.toString(arr)  
    
    for(int n: arr)   
       System.out.println(n+", ");  
    
    for (int i = 0; i < arr.length; i++) {  
       System.out.print(arr[i] + ", ");  
    }  
    
    System.out.println(Arrays.asList(arr));  
    
    Arrays.asList(arr).stream().forEach(s -> System.out.println(s));

    定位元素位置

    Arrays.binarySearch(str);//有序数组
    Arrays.asList.indexOf(str);
    展开全文
  • 数组基本操作

    2013-06-06 04:03:25
    java数组基本操作 查找最大元素 选择排序 优化选择排序 冒泡排序 交换数组元素
  • 二维数组基本操作

    2012-06-23 11:19:06
    二维数组基本操作的功能有:键盘输入稀疏矩阵,随机产生稀疏矩阵,显示稀疏矩阵,压缩稀疏矩阵,显示压缩稀疏矩阵,解压稀疏矩阵,等等。
  • 数组基本操作方法

    千次阅读 2019-06-25 08:59:07
    数组基本操作 1、往数组中添加一个元素: push方法(在尾部添加)unshift方法(在头部添加) 二者均返回数组长度 2、从数组中删除一个元素: pop() 方法(在尾部删除)shift() 方法(在头部删除) 二者均...
  • IDEA 数组基本操作

    2020-05-08 09:59:22
    IDEA 数组基本操作 import java.util.*; public class test02 { public static void main(String [] args) { System.out.println("请输入5个数字:"); int [] array1 = new int[10]; Scanner sc...
  • angularjs数组基本操作

    千次阅读 2018-04-07 16:59:52
    1:ng-click,ng-model,ng-bind,ng-class,ng-hide,ng-app 2:placeholder, 3:{}中加入代码“:true|false”,使用逗号隔开,可以控制包括样式,显示与隐藏等功能,}1、数组的创建?12345var arrayObj = new Array();//...
  • 它是Python科学计算的基本包。 Numpy除了具有科学用途外,还可以作为通用数据的高效多维容器。 Numpy中的数组 Numpy中的数组是一个元素表(通常是数字),所有元素都是相同的类型,由一个正整数元组索引。在Numpy中...
  • Matlab系列之数组基本操作

    千次阅读 2020-08-09 22:21:27
    本篇记录的是基本的数组操作,将包括数组元素的寻址、查找和排序,本来是打算本矩阵的基本操作也介绍下,不过时间比较感觉不太够,就留到下一篇再进行记录了,先把上一篇和本篇的内容好好吸收吧,内容说多不多,但是...
  • 1 声明数组 // 动态初始化(指定长度) String[] aArray = new String[5]; // 其中元素自动拥有默认值。如果是i整数类型,默认为0;如果是浮点类型,默认0.0;如果是字符类型,默认‘\u0000’;如果是布尔类型,默认...
  • 【C++】数组基本操作

    万次阅读 多人点赞 2019-06-06 10:50:14
    数组及常见操作数组数组声明数组初始化数组常见操作vector初始化vector常见操作 数组 数组与vector:如果不确定元素的个数,请使用vector。 数组声明 数组声明:a[d],a是数组名,d是数组的维度(维度必须大于0并且...
  • Java数组基本操作

    万次阅读 多人点赞 2018-09-10 16:28:26
    java.util包的Arrays类里面包含了用来操作数组(如排序和搜索)的各种方法。 遍历数组 遍历数组就是获取数组中的每一个元素。通常遍历数组可以使用for循环。 遍历二维数组需要使用双层for循环,通过数组的length...
  • 创建一个数组, 实现以下功能: 1)init()初始化数组 2)empty()清空数组 3)reverse()数组元素的逆置。 要求:自己设计函数的参数,返回值。 主要思想: 数组的空间大小需要根据用户的需要开辟,用...
  • 数据结构-数组操作

    2019-06-12 15:25:11
    数据结构中的数组基本操作,我这里是也是为了学习记录我自己的书写的代码过程.其中包含取数组的新建,新增元素,删除元素,取指定索引值,向元素尾部追加元素 等等! 1、 场景 1.1、 中文描述 数据结构中的数组基本操作...
  • 因为有插入操作前面的计数操作,所以连对index的控制也省了… (不知道注释写的清不清楚) void ArrayInsertByIndex ( int * p , int * len , int index , int value ) { int count = 0 ; for ...
  • Ruby 教程,数组学习,数组基本操作

    千次阅读 2018-12-22 21:40:24
    数组定义 myarray = Array.new(10) # 定义长度为10的数组 myarray1 = Array.new(4, "item") # 定义长度为4,并用 'item'填充 myarray2 = [12, 13, 14] 赋值 myarray = ['aa', 'bb', 'cc'] # 数组赋值 ...
  • .一维数组基本操作(逆置)

    千次阅读 2019-03-20 15:57:35
    倒置(指针法) #include<bits/stdc++.h> using namespace std; void reverse(int *d,int n) { int *p1,*p2,t; p1=d; p2=d+n-1; while(p1<p2) { t=*p1; *p1=*p2; *p2=t;...int m...
  • 主要介绍了Java数组基本操作方法整理,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 索引数组 //数组第一种定义 $arr = array(1,2,3); var_dump($arr); //数组第二种定义 $arr = [1,2,3]; var_dump($arr); //数组第三种定义 $arr[0] = 7; $arr[1] = "hello"; var_dump($arr); echo $arr[2];//取值 ...
  • 数组】之二维数组常见操作

    千次阅读 2018-07-22 11:22:24
    二维数组的实质上存储的就是一维数组。 二维数组的定义: 数组类型[ ] [ ] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数] 示例: int [ ][ ] arr = new int[3][4] arr.length=3:二维数组...
  • 用 js有很久了,但都没有深究过js的数组形式。偶尔用用也就是简单的string.split(char)。这段时间做的一个项目,用到数组的地方很多,自以为js高手的自己居然无从下手,一下狠心,我学!呵呵。学了之后才知道,js...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 847,760
精华内容 339,104
关键字:

数组的基本操作