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

 
 
四、程序基本功能
 
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;
			}
		}
	}
}

创建
 
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)
 
currentValue(必须),数组当前元素的值
index(可选), 当前元素的索引值
arr(可选),数组对象本身
 
无法中途退出循环，只能用return退出本次回调，进行下一次回调。
它总是返回 undefined值,即使你return了一个值。
 
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}

一.列表，元祖，：
    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）函数：

序号
方法
1
list.append(obj)
在列表末尾添加新的对象
2
list.count(obj)
统计某个元素在列表中出现的次数
3
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5
list.insert(index, obj)
将对象插入列表
6
list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7
list.remove(obj)
移除列表中某个值的第一个匹配项
8
list.reverse()
反向列表中元素
9
list.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字典包含了以下内置函数：
序号
函数及描述
1
cmp(dict1, dict2)
比较两个字典元素。
2
len(dict)
计算字典元素个数，即键的总数。
3
str(dict)
输出字典可打印的字符串表示。
4
type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：
序号
函数及描述
1
dict.clear()
删除字典内所有元素
2
dict.copy()
返回一个字典的浅复制
3
dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4
dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5
dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6
dict.items()
以列表返回可遍历的(键, 值) 元组数组
7
dict.keys()
以列表返回一个字典所有的键
8
dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9
dict.update(dict2)
把字典dict2的键/值对更新到dict里
10
dict.values()
以列表返回字典中的所有值
11
pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12
popitem()
随机返回并删除字典中的一对键和值。


                

二.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；













                  








      


        

 
 

   

     

       
数组声明
数组初始化
遍历数组
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);