精华内容
下载资源
问答
  • Python numpy实现二维数组和一维数组拼接的方法撰写时间:...print a.shape输出的值应该为(3,)二维数组2.numpy初始化二维数组a = np.array([[1,2,3]]);b = np.array([[1],[2],[3]]);print a.shape//(1,3)prin...

    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]就是排序后的数组.

    blank.gif

    本文实例讲述了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

    blank.gif

    二维数组 二维数组本质上是以数组作为数组元素的数组,即"数组的数组",类型说明符 数组名[常量表达式][常量表达式].二维数组又称为矩阵,行列数相等的矩阵称为方阵.对称矩阵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

    L3Byb3h5L2h0dHAvZmlsZXMuamI1MS5uZXQvZmlsZV9pbWFnZXMvYXJ0aWNsZS8yMDE5MDkvMjAxOTkxODExMTAwMzQ5OS5qcGcmIzA2MzsyMDE5ODE4MTExMDE1.jpg

    本文实例为大家分享了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)、第一种是普通的二维数组的表示方法。(2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示的二维...

    名称:二维数组的几种表示方法

    说明:常用的有以下几种二维数组的表示方法:

    (1)、第一种是普通的二维数组的表示方法。

    (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示的二维数组在内存中的储存方式其实是一样的,不过使用二维数组看起来要简单些,只要不用进行地址转换。

    (3)、第三种表示是用指针数组。本例中的c[i]中的元素其实是地址。这种方法对各个元素大小不一样的情况下比较适用。如:假定有若干个不等长字符串需要我们处理,如果使用a [i ][j]结构,则j必须取这些字符串长度的最大值, 显然这种方法浪费空间。如果采用* a [i ]结构,则由于a中仅保存每个字符串的首地址,而不是串本身,这不仅节约了空间,而且减少了直接对串进行操作的时间。

    (4)、第四种方式为用指向指针的变量来表示。此种方式p是指向指针的指针,不能把普通的二维数组的首地址(如本例中的a)赋给它。(因为a不是指向指针的指针)。可以把第三种方式中的数组指针的首地址赋给它。这种方式用的较少。

    #include

    using namespace std;

    int main()

    {

    int a[3][3] = {{0,1,2},{3,4,5},{6,7,8}};

    int b[9] = {0,1,2,3,4,5,6,7,8};

    int *c[3];

    int **p;

    cout<

    for(int i = 0;i<3;++i)

    {

    for(int j = 0;j<3;++j)

    {

    cout<

    //cout<

    }

    cout<

    }

    cout<

    for(int i = 0;i<3;++i)

    {

    for(int j = 0;j<3;++j)

    {

    cout<

    }

    cout<

    }

    cout<

    for(int i = 0;i<3;++i)

    {

    c[i] = *(a+i); //c[i]指向a数组的第i行首地址

    for(int j = 0;j<3;++j)

    {

    cout<

    }

    cout<

    }

    cout<

    p = c; //p为指向指针的指针,将指针数组c赋给指针变量p

    for(int i = 0;i<3;++i)

    {

    for(int j = 0;j<3;++j)

    {

    cout<

    }

    cout<

    }

    return 0;

    }

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对脚本之家的支持。如果你想了解更多相关内容请查看下面相关链接

    展开全文
  • Python输入二维数组方法前不久对于Python输入二维数组有些不解,今日成功尝试,记以备忘。这里以输入1-9,3*3矩阵为例n=int(input())line=[[0]*n]*nfor i in range(n):line[i]=input().split(' ')print(line)使用数据...

    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中字符串变二维数组的实例讲解

    基于python 二维数组及画图的实例详解

    Python实现二维数组输出为图片

    时间: 2018-04-12

    需要在程序中使用二维数组,网上找到一种这样的用法: #创建一个宽度为3,高度为4的数组 #[[0,0,0], # [0,0,0], # [0,0,0], # [0,0,0]] myList = [[0] * 3] * 4 但是当操作myList[0][1] = 1时,发现整个第二列都被赋值,变成 [[0,1,0], [0,1,0], [0,1,0], [0,1,0]] 为什么...一时搞不懂,后面翻阅The Python Standard Library 找到答案 list * n->n sha

    1.二维数组取值 注:不管是二维数组,还是一维数组,数组里的数据类型要一模一样,即若是数值型,全为数值型 #二维数组 import numpy as np list1=[[1.73,1.68,1.71,1.89,1.78], [54.4,59.2,63.6,88.4,68.7]] list3=[1.73,1.68,1.71,1.89,1.78] list4=[54.4,59.2,63.6,88.4,68.7] list5=np.array([1.73,1.68,1.71,1.89,1.78])

    对于二维数组,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

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

    关于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

    L3Byb3h5L2h0dHAvZmlsZXMuamI1MS5uZXQvZmlsZV9pbWFnZXMvYXJ0aWNsZS8yMDE4MTAvMjAxODEwMTcxNDMxNTk5MjMucG5nJiMwNjM7MjAxODkxNzE0MzIxMg==.jpg

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

    1.实测,这个版本在32位window7和python3.2环境下正常使用. 2.使用方法:把解压后所得的chardet和docs两个文件夹拷贝到python3.2目录下的Lib\site-packages目录下就可以正常使用了. 3.判断文件编码的参考代码如下: file = open(fileName, "rb")#要有"rb",如果没有这个的话,默认使用gbk读文件. buf = file.read() result = chardet.detect(buf)

    如何根据二维数组中的某一行或者某一列排序?假设data是一个numpy.array类型的二维数组,可以利用numpy中的argsort函数进行实现,代码实例如下: data = data[data[:,2].argsort()] #按照第3列对行排序 注意:argsort返回的只是排好序后的行索引,不会改变原数组. 按照某行进行排序,可以利用转置操作,代码如下所示: data = data.T(data.T[:,2].argsort()).T # 按照第3行对列进行排序 也可以直接按行进行排序,

    1. 使用输入值初始化列表 nums = [] rows = eval(input("请输入行数:")) columns = eval(input("请输入列数:")) for row in range(rows): nums.append([]) for column in range(columns): num = eval(input("请输入数字:")) nums[row].append(num) print(nums) 输出结果为: 请

    以三维数组为例 先申请1个一维数组空间: mat = [None]*d1 d1是第一维的长度. 再把mat中每个元素扩展为第二维的长度: for i in range(len(mat)): mat[i][j] = [None]*d2 类似的,把mat中每个元素扩展为第三维的大小: for i in range(len(mat)): for j in range(len(mat[0]): mat[i][j] = [None]*d3 以上是创建的"数组"其实是list类,不是严格意义的数组

    如下所示:

    <?php //定义二维索引数组 $arr = array( array("101","李军","男","1976-02-20","95033"), array("103","陆君","男","1974-06-03","95031"), array("10

    python中字符串数组如何逆序排列?下面给大家介绍几种方法: 1.数组倒序: 原始元素的倒序排列 (1)切片 >>> arr = [1,2,3,4,3,4]>>> print (arr[::-1])[4, 3, 4, 3, 2, 1] (2)reverse() >>> arr = [1,2,3,4,3,4]>>> arr.reverse()>>> print (arr)[4, 3, 4, 3, 2, 1] (3)r

    展开全文
  • C语言 二维数组

    千次阅读 2016-01-15 22:21:24
    # 二维数组基本概念 ##1.二维数组的基本概念 - 所谓多维数组就是一个一... +可以看作由一维数组a[0]和一维数组a[1]组成,这两个一维数组都包含了3个int类型的元素 ##2.二维数组的定义 - 格式:  +数据类型 数组名[一维

    # 二维数组基本概念

    ##1.二维数组的基本概念

    - 所谓多维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。

    - 示例

        +int a[2][3]

        +可以看作由一维数组a[0]和一维数组a[1]组成,这两个一维数组都包含了3个int类型的元素

    ##2.二维数组的定义

    - 格式:

        +数据类型 数组名[一维数组的个数][一维数组的元素个数]

           *  数据类型 数组名[行数][列数]

        +其中"一维数组的个数"表示当前二维数组中包含多少个一维数组

        +其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数

    ##3.二维数组的初始化

    - 二维数的初始化可分为两种:

        +定义的同时初始化

           * 按行分段赋值

           * 按行连续赋值

        +先定义后初始化

    - 定义的同时初始化

    - 先定义后初始化

    int a[2][3];

    a[0][0] = 80;

    a[0][1] = 75;

    a[0][2] = 92;

    a[1][0] = 61;

    a[1][1] = 65;

    a[1][2] = 71;

    - 按行分段赋值

    int a[2][3]={ {80,75,92}, {61,65,71}};

    - 按行连续赋值

    int a[2][3]={ 80,75,92,61,65,71};

    - 其它写法

        +完全初始化,可以省略第一维的长度

    int a[][3]={{1,2,3},{4,5,6}};

    int a[][3]={1,2,3,4,5,6};

        +部分初始化,可以省略第一维的长度

           * 为初始化的部分默认为0

    int a[][3]={{1},{4,5}};

    int a[][3]={1,2,3,4};

       >+ 注意: 有些人可能想不明白,为什么可以省略行数,但不可以省略列数。也有人可能会问,可不可以只指定行数,但是省略列数?

    其实这个问题很简单,如果我们这样写:

    int a[2][] = {1, 2, 3, 4, 5, 6}; // 错误写法

    大家都知道,二维数组会先存放第1行的元素,由于不确定列数,也就是不确定第1行要存放多少个元素,所以这里会产生很多种情况,可能1、2是属于第1行的,也可能1、2、3、4是第一行的,甚至1、2、3、4、5、6全部都是属于第1行的

        +指定元素的初始化

           * 未初始化的部分默认为0

    int a[2][3]={[1][2]=10};

    int a[2][3]={[1]={1,2,3}}

    ##3.二维数组的应用

    - 生活中的应用

    - 游戏中的应用

    # 二维数组与函数

    ##1.二维数组的元素作为函数参数

    - 二维数组的元素就相当于变量,作为函数参数与变量相同

    void test(char c);

    int main(int argc, const char * argv[]) {

       char cs[2][3] =

        {

           {'l', 'n', 'j'},

           {'l', 'm', 'j'}

       };

       printf("cs[0][0] = %c\n", cs[0][0]);

       test(cs[0][0]);

       printf("cs[0][0] = %c\n", cs[0][0]);

       return 0;

    }

    void test(char c)

    {

        c= 'w';

       printf("我被执行了\n");

    }

    输出结果:

    cs[0][0] = l

    我被执行了

    cs[0][0] = l

    ##2.二维数组中的一维数组作为函数

    - 二维数组的一维数组实际上就是一个一维数组,作为函数参数与一维数组相同

    void test(char c[]);

    int main(int argc, const char * argv[]) {

       char cs[2][3] =

        {

           {'l', 'n', 'j'},

           {'l', 'm', 'j'}

       };

        printf("cs[0][0]= %c\n", cs[0][0]);

       test(cs[0]);

       printf("cs[0][0] = %c\n", cs[0][0]);

       return 0;

    }

    void test(char c[])

    {

       c[0] = 'w';

       printf("我被执行了\n");

    }

    输出结果:

    cs[0][0] = l

    我被执行了

    cs[0][0] = w

    ```

    ##3.二维数组作为函数参数

    - **二维数组作为函数参数是地址传递**

    - 二维数组作为函数形参,参数中一维数组的元素个数不可以省略

    void test(char cs[2][]) // 错误写法

    {

       printf("我被执行了\n");

    }

     

    void test(char cs[2][3]) // 正确写法

    {

       printf("我被执行了\n");

    }

     

    void test(char cs[][3]) // 正确写法

    {

       printf("我被执行了\n");

    }

    - 二维数组作为函数参数,在被调函数中不能获得其有多少行,需要通过参数传入。

    void test(char cs[2][3])

    {

       int row = sizeof(cs);

       printf("row = %zu\n", row);

    }

    输出结果:

    row = 8

     

    - 二维数组作为函数参数,在被调函数中可以计算出二维数组有多少列

    void test(char cs[2][3])

    {

       size_t col = sizeof(cs[0]);

       printf("col = %zd\n", col);

    }

    输出结果:

    col = 3

    # 字符串常用方法

    ##1.字符串长度

    - 利用sizeof字符串长度

        +因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。

       char name[] = "520it";

       int size = sizeof(name);// 包含\0

       printf("size = %d\n", size);

        输出结果:6

    - 利用系统函数

        +格式: strlen(字符数组名)

        +功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。

       char name[] = "520it";

       size_t len = strlen(name2);

       printf("len = %lu\n", len);

        输出结果:5

    - 以“\0”为字符串结束条件进行统计

    /**

     *  自定义方法计算字符串的长度

     *

     * @param name 需要计算的字符串

     *

     * @return 不包含\0的长度

     */

    int myStrlen2(char str[])

    {

       //    1.定义变量保存字符串的长度

       int length = 0;

       while (str[length] != '\0')

        {

           length++;//1 2 3 4

        }

       return length;

    }

    /**

     *  自定义方法计算字符串的长度

     *

     * @param name  需要计算的字符串

     * @param count 字符串的总长度

     *

     * @return 不包含\0的长度

     */

    int myStrlen(char str[], int count)

    {

    //   1.定义变量保存字符串的长度

       int length = 0;

    //   2.通过遍历取出字符串中的所有字符逐个比较

       for (int i = 0; i < count; i++) {

    //       3.判断是否是字符串结尾

           if (str[i] == '\0') {

               return length;

           }

           length++;

        }

       return length;

    }

    # 字符串练习

     

    - 编写一个函数char_contains(charstr[],char key),

         如果字符串str中包含字符key则返回数值1,否则返回数值0

    int charContaines(char name[], char key)

    {

       int index = 0;

       while (name[index] != '\0') {

           if (key == name[index]) {

               return 1;

           }

           index++;

        }

       return 0;

    }

    int charContaines(char name[], char key)

    {

    //   int index = 0;

       int index = -1;

       while (name[++index]) {

           if (key == name[index]) {

               return 1;

           }

        }

       return 0;

    }

    int charContaines(char name[], char key)

    {

       int index = -1;

    //        取出name中的元素判断是不是要找的key,如果不是就继续找

    //        但是必须要求取出的元素也不是\0,因为如果取出的元素是\0代表字符串已经遍历完了

       while (name[++index] != key && name[index] != '\0');

    //   循环结束只有两种可能,1.找到了key, 2.字符串遍历到了结尾

    //    判断当前索引对应的元素是否是\0,如果是\0代表字符串到了结尾都没有找打

    //   int rs = name[index] == '\0' ? 0 : 1;

    //   int rs = name[index] ? 1 : 0;

    //   return rs;

       return name[index] ? 1 : 0;

    }

    # 字符串数组

    ##1. 字符串数组基本概念

    - 字符串数组其实就是定义一个数组保存所有的字符串

     

        +1.一维字符数组中存放一个字符串,比如一个名字char name[20] = “nj”

     

        +2.如果要存储多个字符串,比如一个班所有学生的名字,则需要二维字符数组,char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)

     

        +3. 如果要存储两个班的学生姓名,那么可以用三维字符数组char names[2][15][20]

    ##2.字符串数组的初始化

    1.char names[2][10] = { {'l','n','j','\0'},{'l','m','j','\0'} };

    2.char names2[2][10] = { {"lnj"},{"lmj"} };

    3.char names3[2][10] = { "lnj","lmj" };

    # 字符串输入输出

    ##1.字符串输出

    - 在采用字符串方式后,字符数组的输入输出将变得简单方便。除了上述用字符串赋初值的办法外,还可用printf函数和scanf函数一次性输出输入一个字符数组中的字符串,而不必使用循环语句逐个地输入输出每个字符。

    - 使用的格式字符串为“%s”,表示输入、输出的是一个字符串

    字符串的输出

    - 输出

        +%s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出,直到遇到\0位置

    char ch[] = "lnj";

    printf("%s\n", ch);

    - \0引发的脏读

    char name[] = {'c', 'o', 'o', 'l' , '\0'};

    char name2[] = {'l', 'n', 'j'};

    printf("name2 = %s\n", name2);

    输出结果: lnjcool

    ##2.字符串输入

    char ch[10];

    scanf("%s",ch);

    - 注意:

        +对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度

        +ch最多存放由9个字符构成的字符串,其中最后一个字符的位置要留给字符串的结尾标示‘\0’当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符。

    ##2.练习

    - 使用 scanf() 从控制台输入一个字符串,然后使用 printf()将其输出。

       char str[9];

       scanf("%s", str);

       printf("str = %s\n", str);

    # 指针基本概念

    ##1.什么是地址

    - 生活中的地址:

    - 内存地址:

    - 地址与内存单元中的数据是两个完全不同的概念

        +地址如同房间编号

        +内存单元如同房间

        +内存单元中存放着数据

    - 变量地址:

        +系统分配给"变量"的"内存单元"的起始地址

    如:

    char c = 'a'; // 占用1个字节

    那么变量c的地址为:0x10A5

    int n = 250; // 占用4个字节

    那么变量c的地址为:0x10A1

    ##2.什么是指针

    - 在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据. 由于通过地址能找到所需的变量单元,可以说,地址指向该变量单元。因此,将地址形象化的称为“指针”

    - 内存单元的指针(地址)和内存单元的内容是两个不同的概念。

    # 指针变量基本概念

    ##1.什么是指针变量

    - 在C语言中,允许用一个变量来存放指针,这种变量称为指针变量。因此,一个指针变量的值就是

    某个内存单元的地址或称为某内存单元的指针。

        +严格意义上说,指针是一个地址,是一个常量

        +针变量是存放一个地址,是一个变量。

    - 示例

    ##2.定义指针变量的格式

    - 指针变量的定义包括两个内容:

        +指针类型说明,即定义变量为一个指针变量;

        +指针变量名;

    ![](./images/zzbldygs.png)

       >+ 其中,*表示这是一个指针变量,变量名即为定义的指针变量名,类型说明符表示本指针变量所指向的变量的数据类型。

    - 示例

    char *p; // 一个用于指向字符形变量的指针

    int *q; // 一个用于指向整形变量的指针

    long *t; // 一个用于指向长整形变量的指针

    float *r; // 一个用于指向单精度浮点形变量的指针

    double *s; // 一个用于指向双精度浮点形变量的指针

    - 注意

        +1)在定义指针时,“*”号表示定义的变量是指针变量,变量的值只能存放地址。

        +2)一个类型的指针只能指向同类型的变量,不能指向其他类型的变量。

    + 3)指针也可以被声明为全局、静态局部和局部的。

    # 指针变量初始化

    ##1.指针变量的初始化方法

    - 指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化

        + 定义的同时进行初始化

    int a = 5;

    int *p = &a;

        + 先定义后初始化

    int a = 5;

    int *p;

    p=&a;

        + 把指针初始化为NULL

    int *p=NULL;

    int *q=0;

    - 不合法的初始化:

        + 指针变量不能被赋值一个整数值(因为我们不知道这个整形常量是内存哪块地址

    int *p;

    p =  250; // 错误写法

        + 被赋值的指针变量前不能再加“*”

    int *p;

    *p=&a; //错误写法

    - 注意:

    - 多个指针变量可以指向同一个地址

        -指针的指向是可以改变的

    int a = 5;

    int *p = &a;

    int b = 10;

    p = &b; // 修改指针指向

    - 指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针

        + 野指针可能会导致程序崩溃

        + 野指针访问你不该访问数据

        + 所以指针必须初始化才可以访问其所指向存储区域

    ##2.访问指针所指向的存储空间

    - C语言中提供了地址运算符&来表示变量的地址。其一般形式为:

        + &变量名;

    - C语言中提供了*来定义指针变量和访问指针变量指向的内存存储空间

        + 在定义变量的时候 * 是一个类型说明符,说明定义的这个变量是一个指针变量

    int *p=NULL; // 定义指针变量

        + 在不是定义变量的时候 *是一个操作符,访问指针所指向存储空间

    int a = 5;

    int *p = &a;

    printf("a =%d", *p); // 访问指针变量

    # 指针练习

    ##1.

    -  定义一个函数交换两个变量的值

    void swap(int*v1,int *v2)

    {

        int temp;

        temp = *v1;

        *v1 = *v2;

        *v2 = temp;

    }

    - 写一个函数,同时返回两个数的和与差

    intsumAndMinus(int v1, int v2, int *v3)

    {

        *v3 = v1 - v2;

        return v1 + v2;

    }

    # 多级指针

    ##1.二级指针介绍

    - 如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针变量。也称为“二级指针”

        char c = 'a';

        char *cp;

        cp = &c;

        char **cp2;

        cp2 = &cp;

        printf("c = %c", **cp2);

    ##2.多级指针介绍

    int ***m1; 取值***m1

    int *****m2 取值*****m2

    # 指针类型

    ##1.指针为什么要区分类型

    - 在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。比如,在16位编译器环境下,任何一个指针变量都只占用8个字节,并不会随所指向变量的类型而改变。

    - 虽然所有的指针都只占8个字节,但不同类型的变量却占不同的字节数。

        + 一个int占用4个字节,一个char占用1个字节,而一个double占用8字节;

        + 现在只有一个地址,我怎么才能知道要从这个地址开始向后访问多少个字节的存储空间呢,是4个,是1个,还是8个。

        + 所以指针变量需要它所指向的数据类型告诉它要访问多少个字节存储空间

    # 指针与数组

    ##1.数组指针的概念及定义

    - 数组元素指针

        + 一个变量有地址,一个数组包含若干元素,每个数组元素都有相应的地址 指针变量可以指向数组元素(把某一元素的地址放到一个指针变量中) 所谓数组元素的指针就是数组元素的地址

        printf(“%p %p”, &(a[0]), a);

    输出结果:0x1100, 0x1100

    ```

        >+ 注意: 数组名a不代表整个数组,只代表数组首元素的地址。

        >+ “p=a;”的作用是“把a数组的首元素的地址赋给指针变量p”,而不是“把数组a各元素的值赋给 p”

    ##2.使用指针引用数组元素

    - 可以用指针去访问数组

        int main (void)

    {

          int a[5] = {2, 4, 6, 8, 22};

          int *p;

          // p = &(a[0]); /* p has addressof  a[1]*/

          p = a;

          printf(“%d %d\n”,a[0],*p);

    }

    输出结果: 2, 2

    ```

    - 在指针指向数组元素时,允许以下运算:

        + 加一个整数(用+或+=),如p+1

        + 减一个整数(用-或-=),如p-1

        + 自加运算,如p++,++p

        + 自减运算,如p--,--p

        >+ 如果指针变量p已指向数组中的一个元素,则p+1```指向```同一数组中的下一个元素,p-1```指向```同 一数组中的上一个元素。

    - 结论:

        + 引用一个数组元素,可用下面两种方法:

            * 下标法,如a[i]形式

            * 指针法, *(p+i)形式

    - 注意:

        + 数组名虽然是数组的首地址,但是,数组名所所保存的数组的首地址是不可以更改的

    ```

        int x[10];

             x++; //illegal

             int* p = x;

             p++; //legal

    ##3.指针变量之间运算

    - 两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。

        + 实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。

        + (pointer2地址值 -pointer地址值) /sizeof(所指向数据类型)

    - 注意:

        + 指针之间可以相减,但不可以相加(相加无意义)

    # 指针与字符串

    ##1.字符串指针

    - 定义字符串的两种方式

        + 字符数组

    ```

    char string[]=”Ilove China!”;

    printf("%s\n",string);

        + 字符串指针指向字符串

            * 格式: ```char *变量名="字符串内容";```

    ```

    char*str="abc"

    ```

    - 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别

    ```

    char c = 'b';

    char *p=&c;// 表示p是一个指向字符变量c的指针变量。

    char *s="CLanguage"; // 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。

    ```

    - 注意:

        + 1、使用字符数组来保存的字符串是保存栈里的,保存栈里面东西是可读可写,所有我 们可以改变里面的字符当把一个字符串常量赋值一个字符数组的时候,那么它会把字符串常量中的没有字符都放到字符数组里面

        + 2、使用字符指针来保存字符串,它保存的是字符串常量地址,常量区是只读的,所 以我们不可以修改字符串中的字符

    ##2.字符串指针使用注意事项

    - 可以查看字符串的每一个字符

    ```

    char *str ="lnj";

    for(int i = 0; i< strlen(str);i++)

    {

        printf("%c-", *(str+i));

    }

    输出结果:l-n-j

    ```

    - 不可以修改字符串内容

    ```

    char *str ="lnj";

    *(str+2) = 'y';// 错误

    ```

    - 不能够直接接收键盘输入

    ```

    char *str;

    scanf("%s",str);

    ```

        >+ 错误的原因是:str是一个野指针,他并没有指向某一块内 存空间,所以不允许这样写如果给str分配内存空间是可以这样用 的

    # 返回指针的函数

    ---

    ##1.指针函数概念

    - 前面我们介绍过,所谓函数类型是指函数返回值的类型。在C语言中允许一个函数的返回值是一个指针(即地址),这种返回指针值的函数称为指针型函数。

    ##2.指针函数的定义和使用

    - 格式:

    ```

    类型说明符 *函数名(形参表) {

        /*函数体*/

    }

    ```

        >+ 其中函数名之前加了“*”号表明这是一个指针型函数,即返回值是一个指针。类型说明符表示了 返回的指针值所指向的数据类型。

    # 指向函数指针

    ##1.为什么指针可以指向一个函数?

    - 函数作为一段程序,在内存中也要占据部分存储空间,它也有一个起始地址,即函数的入口地址。函数有自己的地址,那就好办了,我们的指针变量就是用来存储地址的。因此,可以利用一个指针指向一个函数。其中,函数名就代表着函数的地址。

    ##2.针函数的定义和使用

    - 格式:

    ```

    函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);

    ```

        + 其中“类型说明符”表示被指函数的返回值的类型。

        + “(* 指针变量名)”表示“*”后面的变量是定义的指针变量。

        + 最后的空括号表示指针变量所指的是一个函数。

    ```

        int sum(int a,int b)

        {

            return a + b;

        }

        int (*p)(int,int);

        p = sum;

    ```

    - 技巧

        + 1、把要指向函数头拷贝过来

        + 2、把函数名称使用小括号括起来

        + 3、在函数名称前面加上一个*

        + 4、修改函数名称

    ---

    - 应用场景

        + 调用函数

        + 将函数作为参数在函数间传递

    ##3.使用注意

    - 由于这类指针变量存储的是一个函数的入口地址,所以对它们作加减运算(比如p++)是无意义的

    - 函数调用中"(*指针变量名)"的两边的括号不可少,其中的*不应该理解为求值运算,在此处它 只是一种表示符号

    # 字符串的基本概念

    ##1.字符串概念

    - 字符串是位于双引号中的字符序列

        + 在内存中以“\0”结束,所占字节比实际多一个

    ---

    ##2.字符串的初始化

    - 在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。前面介绍字符串常量时,已说明字符串总是以‘\0’作为串的结束符。因此当把一个字符串存入一个数组时,也把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。有了‘\0’标志后,就不必再用字符数组的长度来判断字符串的长度了。

    - 初始化

    ```

        char name[9] = "lnj"; //在内存中以“\0”结束, \0ASCII码值是0

        char name1[9] = {'l','n','j','\0'};

        char name2[9] = {'l','n','j',0};

        char name3[9] = {'l','n','j'};//静态数组如果没有赋值默认就是0,0就相当于\0

    ```

    - 错误的初始化方式

    ```

         //不正确地写法,结尾没有\0 ,只是普通的字符数组

        char name4[] = {'l','n','j'};

         //   \0的作用:字符串结束的标志

        char name[] = "c\0ool";

         printf("name = %s\n",name);

    输出结果: c

    # 字符串常用方法(二)

    - C语言提供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转换、复制、搜索几类。使用这些函数可大大减轻编程的负担。

        + 用于输入输出的字符串函数,在使用前应包含头文件"stdio.h"

        + 使用其它字符串函数则应包含头文件"string.h"。

    ##1.字符串输出函数:puts

    - 格式: puts(字符数组名)

    - 功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。

    - 优点:

        + 自动换行

        + 可以是数组的任意元素地址

    - 缺点

        + 不能自定义输出格式, 例如puts("hello %s");

    ```

    char ch[] ="lnj";

    puts(ch);

    输出结果: lnj

    ```

        >+ 从程序中可以看出puts函数中可以使用转义字符,因此输出结果成为两行。puts函数完全可以由printf函数取代。当需要按一定格式输出时,通常使用printf函数。

     

    展开全文
  • C语言模拟题9-二维数组和指针第九部分:二维数组与指针一、选择题(1)有以下程序main(){int a[3][3],*p,i;p=&a[0][0];for(i=0;i<9;i++)p[i]=i;for(i=0;i<3;i++)printf("%d ",a[1][i]);}程序运行后的输出...
  • 二维数组和指针

    2020-02-12 17:43:16
    1、二维数组a由若干个一维数组组成 像上面定义的数组a,我们可以理解为由a[0]、a[1]、a[2]三个元素组成,而它们又分别是一个一个一维数组 数组名是一个地址,其值得第一个元素的地址,此值得基类型就是数组元素的...
  • 二维数组和数组元素地址

    千次阅读 2017-07-28 15:58:09
    1.二维数组a由若干个以为数组组成 像上面定义的数组a,我们可以理解为由a[0],a[1],a[2]三个元素组成,而他们有分别是一个一维数组 通过我们前面学过的知识可以知道,数组名是一个地址,其值是第一个元素的地址,而...
  • 二维数组

    2014-03-20 19:19:00
    二维数组作为参数传递(用二维数组处理矩阵),但是希望接受传递二维数组参数的函数可以处理任意维度的数组(希望矩阵的行数和列数都是不固定的)。【以下】----------------------------------------------------...
  • 二维数组的传参

    2015-10-01 09:47:26
    二维数组的存储方式是和一维数组没什么区别,但是用二维数组做参数,它的形参该怎样写?要注意的是:函数中的形参其实就相当于一个声明,并不产生内存分配,形参的目的就是要让编译器知道函数参数的数据类型。 正确...
  • 一、二维数组的基本概念 1.1 二维数组的内存映像 从内存角度看,二维数组...一维数组int a[10]与二维数组int b[2][5]的对应关系 一维数组 a[0] a[1] a[4] a[5] a[9] 二维数组 b[0][0] b[0][1] b[0][4] b[1...
  • Net二维数组的使用

    千次阅读 2017-02-28 09:44:11
    简要说明二维数组的内存结构、定义及调用方法。
  • C语言入门系列之6.一维和二维数组

    千次阅读 2020-04-27 10:18:31
    二维数组的定义格式为类型说明符 数组名[常量表达式][常量表达式];,可理解为元素是一维数组的一维数组;引用形式是数组名[下标][下标],可以有多种方式进行初始化。利用二分法查找数据可以大大加快查询速率;内存...
  • 【简答题】以下函数rotate的功能是:将N行N列的二维数组a中的最后一行放到N行N列的二维数组b的第0列中,把二维数组a中的第0行放到二维数组b的最后一列中,二维数组b中其他数据不变,请在下划线处填空。#define N 4...
  • 指针和二维数组

    千次阅读 2012-02-10 18:19:51
    要用指针处理二维数组,首先要解决从存储的角度对二维数组的认识问题。我们知道,一个二维数组在计算机中存储时,是按照先行后列的顺序依次存储的,当把每一行看作一个整体,即视为一个大的数组元素时,这个存储的...
  • 二维数组和二维指针

    千次阅读 2016-01-01 15:54:52
    二维数组和二维指针 题号 题目 答案 解析 1 以下程序的输出结果是______。 main() { int i,x[3][3]={9,8,7,6,5,4,3,2,1},*p=&x[1][1];  for(i=0;i } A、52   ...
  • C语言C 072二维数组.ppt

    2020-04-19 10:11:13
    * (2)若定义int a[3][4],则对a正确引用是 A) a [ 2 ][ 4 ] B) a [ 1,3] C) a (2(1) D) a [1+1][ 0 ] (1)以下二维数组说明方式中正确的是 A) int a[3][ ]; B) float a(3,4; C) double a[1][4]; D) float a(3(4; ...
  • 注:为了方便解释,二维数组都按2行3列计算;下面的例子都是亲测有效 一、写法及含义 1、int a[2][3] = { {2,4,6}, {20,40,60} };:定义了一个行为2,列为3的二维数组,所以sizeof(c)为3*2*4=24字节 2、int(*b)[3...
  • 要用指针处理二维数组,首先要解决从存储的角度对二维数组的认识问题。我们知道,一个二维数组在计算机中存储时,是按行存储的,即先存储第一行的元素,再存储第二行的元素。当把每一行看作一个整体,即作为一个大的...
  • 第一部分:一维数组 我们之前所学过的数据类型都属于基本数据类型(整型、浮点型、字符型)。实际上C语言不仅仅可以操作基本数据类型,还可以操作构造数据类型(如结构体、数组等)。 数组是有序数据的结合,数组中...
  • C语言:关于二维数组做形参

    千次阅读 2015-02-15 10:57:04
    二维数组的存储方式是和一维数组没什么区别,但是用二维数组做参数,它的形参该怎样写?要注意的是:函数中的形参其实就相当于一个声明,并不产生内存分配,形参的目的就是要让编译器知道函数参数的数据类型。 ...
  • *p[3]这个是一个指针数组,它所代表的意思是数组中的每一个元素都是一个指针变量,而(*p)[3],p是一个指针变量,表示指向一个含有3个整型元素的一维数组。 复制代码代码如下: int i,j;  int a[2][3]={3,4,5,6,7...
  • C++二维数组做函数参数 二维数组做函数参数的形式主要有: /对于一个m行n列int元素的二维数组 //函数f的形参形式 f(int daytab[m][n]) {...} //以下两种可以忽略行数 f(int daytab[][n]) {...} f(int (*daytab)...
  • Python实现二维数组输出为图片 对于二维数组,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 ...
  • 二维数组作为参数传递(用二维数组处理矩阵),但是希望接受传递二维数组参数的函数可以处理任意维度的数组(希望矩阵的行数和列数都是不固定的)。 【以下】 ----------------------------------------------...
  • 关于二维数组传参做形参 二维数组的存储方式是和一维数组没什么区别,但是用二维数组做参数,它的形参该怎样写?要注意的是:函数中的形参其实就相当于一个声明,并不产生内存分配,形参的目的就是要让编译器...
  • —————————————————————————————————— 一、辨析数组形式的含义定义3行4列的二维数组a如下:int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};一个没什么特别的二维数组,我的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,689
精华内容 10,275
关键字:

以下对二维数组a的正确说明是