精华内容
下载资源
问答
  • 实用标准文案 互换性与技术测量知识点 第 1 章 绪言 互换性是指在同一规格的一批零部件中任取一件在装配时不 需经过任何选择修配或调整就能装配在整机上并能满足使用性 能要求的特性 互换性应具备的条件 装配前不换 ...
  • 互换性与测量技术基础知识点总结

    千次阅读 多人点赞 2019-12-04 12:48:06
    互换性与测量技术基础知识点总结绪论光滑圆柱体结合的公差与配合(第一章) 绪论 互换性的含义 公差的含义 内、外互换 优先数系 R5, R10, R20, R40 派生系列,如 R10/3 光滑圆柱体结合的公差与配合(第一章)...

    绪论

    • 互换性的含义
    • 公差的含义
    • 内、外互换
    • 优先数系 R5, R10, R20, R40
    • 派生系列,如 R10/3

    光滑圆柱体结合的公差与配合(第二章)

    • 几何要素
      组成要素,导出要素,公称组成要素,公称导出要素,提取组成要素,提取导出要素,拟合组成要素,拟合导出要素。
    • 孔和轴
    孔槽和键槽宽表面键宽表面
    • 尺寸
    项目
    公称尺寸Dd
    极限尺寸 D m a x D_ {max} Dmax, D m i n D_ {min} Dmin d m a x d_ {max} dmax, d m i n d_ {min} dmin
    上极限偏差 E S ES ES e s es es
    下极限偏差 E I EI EI e i ei ei
    尺寸公差 T h T_h Th T s T_s Ts
    • 尺寸公差与极限偏差的比较
      • 极限偏差用于限制实际偏差,公差用于限制误差
      • 极限偏差取决于机床的调整;而公差表示制造精度,反应加工的难易程度
      • 极限偏差反映公差带位置,影响配合的松紧程度;公差反应公差带大小,影响配合精度
    • 配合和配合制
    间隙过渡过盈
    最大间隙 X m a x X_{max} Xmax D m a x − d m i n D_{max}-d_{min} Dmaxdmin D m a x − d m i n D_{max}-d_{min} Dmaxdmin
    最小间隙 X m i n X_{min} Xmin D m i n − d m a x D_{min}-d_{max} Dmindmax 0 0 0
    最大过盈 Y m a x Y_{max} Ymax D m i n − d m a x D_{min}-d_{max} Dmindmax d m a x − D m i n d_{max}-D_{min} dmaxDmin
    最小过盈 Y m i n Y_{min} Ymin 0 0 0 d m i n − D m a x d_{min}-D_{max} dminDmax
    配合公差 T f T_{f} Tf| X m a x X_{max} Xmax- X m i n X_{min} Xmin|| X m a x X_{max} Xmax- Y m i n Y_{min} Ymin|| Y m a x Y_{max} Ymax- Y m i n Y_{min} Ymin|
    • 配合制

      • 基孔制 H
      • 基轴制 h
      • 非标准配合制
    • 标准公差

      • 基本偏差
      • 精度等级
    • 常用公差与配合

      • 优先基孔制
      • 同一公称尺寸上装配几个不同配合性质的零件时,采用基轴制
      • 以标准件为基准件来确定配合制

      测量技术基础(第三章)

      • 量块(块规)
      • 量块的精度
        “级”(含制造误差) :00,0,1,2,3,K(校准级)
        “等” (含测量误差) :1,2,3,4,5
      • 量块的组合
        先选小量块

      几何公差及检测(第四章)

      • 公差项目
        直线度,平面度,圆度,圆柱度,线轮廓度,面轮廓度,平行度,垂直度,倾斜度,位置度,同心度,同轴度,对称度,圆跳动,全跳动。
      • 几何公差附加符号
        包容要求 E,最大实体要求 M,最小实体要求 L,可逆要求 R
      • 几何公差的标注
        框格组成:公差项目+公差值+基准(从左到右)
      • 被测要素表示法
        1.对于组成要素:指向轮廓面或其延长线(与尺寸错开),或指向其引出线的水平线
        2.对于中心导出要素:指向轮廓面(与尺寸对齐
      • 公差带
    几何公差项目公差带
    直线度任意截面两平行直线,给定方向两平行平面,任意方向圆柱面
    平面度两平行平面
    圆度同心圆环(指引箭头垂直于轴线)
    圆柱度同轴圆柱面
    线轮廓度任意截面两平行轮廓线
    面轮廓度两平行轮廓面
    平行度两平行平面,平行于线索(LE)的任一截面内的两平行直线,圆柱面
    垂直度两平行平面,圆柱面
    倾斜度两平行平面,倾斜圆柱
    位置度球面,两平行平面,圆柱面,倾斜的两平行平面
    同轴度圆柱
    对称度两平行平面
    圆跳动任意界面圆环,端面上的任意半径位置的圆柱面
    全跳动圆柱,端面上的圆柱
    • 公差原则
      • 独立原则
      • 相关要求:包容要求,最大实体要求,最小实体要求,可逆要求

      表面粗糙度(第五章)

      • 基本术语
        • 微观几何形状(<1mm),波纹度轮廓(<10mm),形状轮廓(>10mm)
        • 取样长度 l r lr lr,评定长度 l n ln ln
        • 中线
        • 表面粗糙度评定参数: R a , R z , R s m , R m r ( c ) Ra,Rz,Rsm,Rmr(c) Ra,Rz,Rsm,Rmr(c)
      • 表面粗糙度的标注
        • 16%规则
        • 最大规则
        • 传输带( λ c , λ s \lambda_c,\lambda_s λc,λs)
        • 从材料外指向材料内
        • 可以标在形状公差的上方
        • 加工纹理的标注

        光滑工件尺寸的检测(第六章)

        • 验收极限
          • 误收,误废,生产公差,保证公差,工件公差
          • 方案:1.内缩方案,2.A = 0
        • 器具的选择(独立原则时
          • 安全裕度A( u u u),计量器具的测量不确定度允许值( u 1 u_1 u1
        • 光滑极限量规(采用包容要求时
          • 塞规
          • 卡规(环规)

          滚动轴承与孔,轴的互换性

          • 轴承既有外互换,又有内互换
          • 尺寸公差精度等级:0,6,5,4,2
          • 旋转精度:跳动,游隙
          • 壳体孔与轴承外圈配合采用基轴制,轴承内圈与轴颈配合采用基孔制,但都是负偏差
          • 滚动轴承选择
            • 负荷大小:轻,正常,重
            • 负荷类型:固定,旋转,摆动

            尺寸链(第八章)

            • 术语
              • 封闭环,组成环,增环,减环,传递系数
              • 计算
                • 封闭环的尺寸 A 0 A_0 A0
                • 封闭环的公差 A 0 m a x A_{0max} A0max, A 0 m i n A_{0min} A0min

          圆锥结合的互换性(第九章)

          螺纹结合的互换性(第十章)

    名称符号
    大径 D D D, d d d
    小径 D 1 D_1 D1, d 1 d_1 d1
    中径 D 2 D_2 D2, d 2 d_2 d2
    螺距P
    导程 P h Ph Ph
    牙型半角 α / 2 \alpha/2 α/2
    螺纹升角 ψ \psi ψ
    旋和长度S, N, L
    • 对螺纹互换性有影响的几何参数
      • 中径偏差
      • 螺距偏差(影响可旋和性和连接的可靠性)
      • 牙型半角偏差
    展开全文
  • 第一章绪论互丝与 本章学习目的是了解本课程的性质和任务学习要求是懂得 互换性的含义;了解互换性与标准化的关系及其在现代化生产中 的重要意义;了解优先数的基本原理及其应用 互换性原则是机械工业生产的基本技术...
  • C语言重要知识点

    万次阅读 多人点赞 2017-12-04 21:24:47
    C语言最重要的知识点 总体上必须清楚的:  1)程序结构是三种: 顺序结构 、选择结构(分支结构)、循环结构。  2)读程序都要从main()入口, 然后从最上面顺序往下读(碰到循环做循环,碰到选择做选择),有且只有一个...

    C语言最重要的知识点

    总体上必须清楚的:

     1)程序结构是三种:  顺序结构选择结构(分支结构)、循环结构

     2)读程序都要从main()入口, 然后从最上面顺序往下读(碰到循环做循环,碰到选择做选择),有且只有一个main函数。

     3)计算机的数据在电脑中保存是以二进制的形式. 数据存放的位置就是 他的地址.

     4)bit 是指为0 或者1 byte 是指字节, 一个字节 = 八个位.

    概念常考到的:

    1、编译预处理不是C语言的一部分,不占运行时间,不要加分号。C语言编译的程序称为源程序,它以ASCII数值存放在文本文件中。

    2、#define PI 3.1415926; 这个写法是错误的,一定不能出现分号

          define a 1+2          define a (1+2)

         a=a*a=1+2*1+2=5       a=a*a=3*3=9 

    3、每个C语言程序中main函数有且只有一个

    4、在函数中不可以再定义函数。

    5、算法:可以没有输入,但是一定要有输出

    6、break可用于循环结构和switch语句。

    7、逗号运算符的级别最低赋值的级别倒数第二

    第一章C语言的基础知识

    第一节、对C语言的基础认识

    1、C语言编写的程序称为源程序又称为编译单位

    2、C语言书写格式是自由的,每行可以写多个语句,可以写多行。

    3、一个C语言程序有且只有一个main函数,是程序运行的起点

    第二节、熟悉vc++

    1、VC是软件,用来运行写的C语言程序。

    2、每个C语言程序写完后,都是先编译,后链接,最后运行。(.c---à.obj---à.exe)这个过程中注意.c和.obj文件时无法运行的,只有.exe文件才可以运行。(常考!)

    第三节、标识符

    1、标识符(必考内容):

    合法的要求是由字母数字下划线组成。有其它元素就错了。

    并且第一个必须为字母或则是下划线。第一个为数字就错了

    2、标识符分为关键字、预定义标识符、用户标识符。

    关键字:不可以作为用户标识符号main define  scanf  printf 都不是关键字。迷惑你的地方If是可以做为用户标识符。因为If中的第一个字母大写了,所以不是关键字。

    预定义标识符:背诵define scanf  printf  include。记住预定义标识符可以做为用户标识符。

    用户标识符:基本上每年都考,详细请见书上习题。

    第四节:进制的转换

    十进制转换成二进制、八进制、十六进制。

        二进制、八进制、十六进制转换成十进制。

    第五节:整数与实数

    1)C语言只有八、十、十六进制,没有二进制。但是运行时候,所有的进制都要转换成二进制来进行处理。(考过两次)

        a、C语言中的八进制规定要以0开头。018的数值是非法的,八进制是没有8的,逢8进1。 

        b、C语言中的十六进制规定要以0x开头。

    2)小数的合法写法C语言小数点两边有一个是零的话可以不用写

    1.0在C语言中可写成1.

    0.1在C语言中可以写成.1。

    3)实型数据的合法形式:

    a、2.333e-1 就是合法的,且数据是2.333×10-1

    b、考试口诀:ee后必有数,e必为整数请结合书上的例子。

    4) 整型一般是4个字节, 字符型1个字节,双精度一般是8个字节:

      long int x; 表示x是长整型。

        unsigned int x; 表示x是无符号整型。

    第六、七节:算术表达式和赋值表达式

    核心:表达式一定有数值

    1、算术表达式:+,-,*,/,%

       考试一定要注意:“/” 两边都是整型的话,结果就是一个整型。 3/2的结果就是1.

                      “/” 如果有一边是小数,那么结果就是小数。 3/2.0的结果就是1.5

                      “%”符号请一定要注意是余数,考试最容易算成了除号。)%符号两边要求是整数。不是整数就错了。[注意!!!]

    2、赋值表达式:表达式数值是最左边的数值,a=b=5;该表达式为5,常量不可以赋值

    1、int x=y=10: 错啦,定义时不可以连续赋值。

    2、int x,y;

    x=y=10;   对滴,定义完成后可以连续赋值。

    3、赋值的左边只能是一个变量

    4、int x=7.7;对滴,x就是7

    5、float y=7;对滴,x就是7.0

    3、复合的赋值表达式:

       int a=2;

       a*=2+3;运行完成后,a的值是12。

    一定要注意,首先要在2+3的上面打上括号。变成(2+3)再运算。

    复合语句一定用{};

    4、自加表达式:

    自加、自减表达式:假设a=5,++a(是为6), a++(为5);

    运行的机理:++a 是先把变量的数值加上1,然后把得到的数值放到变量a中,然后再用这个++a表达式的数值为6,而a++是先用该表达式的数值为5,然后再把a的数值加上1为6,

    再放到变量a中。 进行了++a和a++后在下面的程序中再用到a的话都是变量a中的6了。

      考试口诀:++在前先加后用++在后先用后加

    5、逗号表达式:

    优先级别最低。表达式的数值逗号最右边的那个表达式的数值。

    (2,3,4)的表达式的数值就是4。

     z=(2,3,4)(整个是赋值表达式) 这个时候z的值为4。(有点难度哦!)

      z=  234 (整个是逗号表达式)这个时候z的值为2。

    补充:

    1、空语句不可以随意执行,会导致逻辑错误

    2、注释是最近几年考试的重点,注释不是C语言,不占运行时间,没有分号。不可以嵌套!

    3、强制类型转换

      一定是 (int)a 不是  int(a),注意类型上一定有括号的。

       注意(int)(a+b) 和(int)a+b 的区别。前是把a+b转型,后是把a转型再加b。

    4、三种取整丢小数的情况

           1、int a =1.6;

                  2、(int)a;  

                    3、1/2; 3/2;

                     4.不丢小数办法,在相应的格式中加前缀.2保留2位,四舍五入

    第八节、字符

    1)字符数据的合法形式::

       '1'字符个字节,"1"是字符串占个字节(含有一个结束符号)。

      '0' 的ASCII数值表示为48,'a' 的ASCII数值是97,'A'的ASCII数值是65。

    一般考试表示单个字符错误的形式:'65'    "1"  

    字符是可以进行算术运算的,记住: '0'-0=48

    大写字母和小写字母转换的方法: 'A'+32='a'  相互之间一般是相差32。

    2)转义字符:

    转义字符分为一般转义字符、八进制转义字符、十六进制转义字符

    一般转义字符:背诵\0、 \n、 \’、 \”、 \\。

    八进制转义字符:  ‘\141’ 是合法的, 前导的0是不能写的。

    十六进制转义字符:’\x6d’ 才是合法的,前导的0不能写,并且x是小写

    3、字符型和整数是近亲:两个具有很大的相似之处

              char a = 65 ; 

                printf(“%c”,a);  得到的输出结果:a

    printf(“%d”, a); 得到的输出结果:65                

    第九章、位运算 

    1)位运算的考查:会有一到二题考试题目。

    总的处理方法:几乎所有的位运算的题目都要按这个流程来处理(先把十进制变成二进制再变成十进制)。

    例1: char a = 6,b;

         b = a<<2;  这种题目的计算是先要把a的十进制6化成二进制,再做位运算。

    例2: 一定要记住,异或的位运算符号” ^ ”。0 异或 1得到1。

                                             0 异或 0得到0。两个女的生不出来

    考试记忆方法:一男(1)一女(0)才可以生个小孩(1)。

    例3: 在没有舍去数据的时候,<<左移一位表示乘以2;>>右移一位表示除以2。   

    第二章

    第一节:数据输出(一)(二)

    1、使用printf和scanf函数时,要在最前面加上#include“stdio.h”

    2、printf可以只有一个参数,也可以有两个参数。(选择题考过一次)

    3、printf(“ 第一部分 ”,第二部分  );把第二部分的变量、表达式、常量以第一部分的形式展现出来!

    4、printf(“a=%d,b=%d”,12, 34) 考试重点!

    一定要记住是将12和34以第一部分的形式现在在终端也就是黑色的屏幕上。考试核心为一模一样在黑色屏幕上面显示为  a=12,b=34          

      printf(“a=%d,\n b=%d”,12, 34)那么输出的结果就是:a=12,

    b=34

    提示输出错误解决办法(整形数组)

    1  printf(i==n?”%d ”:”%d\n”,a[i]);

    2  (i<n-1)printf(“%d ”,a[i]);  prinitf(“%d\n”,a[i]);

       5、int x=017;   一定要弄清楚为什么是这个结果!过程很重要

          printf(“%d”, x); 15

    printf(“%o”, x); 17

    printf(“%#o”,x); 017

    printf(“%x”, x); 11 

    printf(“%#x”,x); 0x11

       6、int x=12,y=34; 注意这种题型

          char z=‘a’;    

          printf(“%d ”,x,y); 一个格式说明,两个输出变量,后面的y不输出

          printf(“%c”,z);      结果为:12a

       7、一定要背诵的

    格式说明

    表示内容

    格式说明

    表示内容

    %d

    整型   int

    %c

    字符  char

    %ld

    长整型 long int

    %s

    字符串

    %f

    浮点型 float

    %o

    八进制

    %lf

    double

    %#o

    带前导的八进制

    %%

    输出一个百分号

    %x%X

    十六进制输出大写

    %5d

     

    %#x

    带前导的十六进制

    举例说明:

    printf(“%2d”,123 );  第二部分有三位,大于指定的两位,原样输出123

    printf(“%5d”,123 );  第二部分有三位,小于指定的五位,左边补两个空格  123

    printf(“%10f”,1.25 ); 小数要求补足6位的,没有六位的补0,。结果为 1.250000

    printf(“%5.3f”,125 ); 小数三位,整个五位,结果为1.250(小数点算一位)

    printf(“%3.1f”,1.25 );小数一位,整个三位,结果为1.3(要进行四舍五入)

    输出时间“%02d:%02d:%02d\n”

    第三节 数据输入

    防止非法输入while~scanf()){}

    多重用例

          1 whilescanf()!=EOF

          2 while(scanf(“”,&a),a!=-1){s[n]=a;n++}

    1、scanf(“a=%d,b=%d”,&a,&b) 考试超级重点!

    一定要记住是以第一部分的格式在终端输入数据。考试核心为:一模一样

    在黑色屏幕上面输入的为  a=12,b=34才可以把12和34正确给a和b 。有一点不同也不行。        

    2、scanf(“%d,%d”,x,y);这种写法绝对错误,scanf的第二个部分一定要是地址!

    scanf(“%d,%d”,&x,&y);注意写成这样才可以!没地址一开始运行就会bug

    3、特别注意指针在scanf的考察

    例如: int x=2;int *p=&x;

    scanf(“%d”,x);   错误          scanf(“%d”,p);正确

    scanf(“%d”,&p);  错误         scanf(“%d”,*p)错误

    4、指定输入的长度 (考试重点)

    终端输入:1234567

    scanf(“%2d%4d%d”,&x,&y,&z);x为12,y为3456,z为7

    终端输入:1 234567     由于1和2中间有空格,所以只有1位给x

    scanf(“%2d%4d%d”,&x,&y,&z);x为1,y为2345,z为67

    5、字符和整型是近亲:

    intx=97;

    printf(“%d”,x);   结果为97

    printf(“%c”,x);   结果为 a

    6、输入时候字符和整数的区别(考试超级重点

    scanf(“%d”,&x);这个时候输入1,特别注意表示的是整数1

    scanf(“%c”,&x);这个时候输入1,特别注意表示的是字符‘1’ASCII为整数48。

    补充说明:

    1)scanf函数的格式考察:

       注意该函数的第二个部分是&a 这样的地址,不是a; 

       scanf(“%d%d%*d%d”,&a,&b,&c);跳过输入的第三个数据。

    2)putchar ,getchar 函数的考查:

       char a = getchar() 是没有参数的,从键盘得到你输入的一个字符给变量a。

       putchar(‘y’)把字符y输出到屏幕中。

    3)如何实现两个变量x ,y中数值的互换(要求背下来)

       不可以把 x=y ,y=x; 要用中间变量 t=x;x=y;y=t

        位运算a=a^b;b=b^a;a=a^b;

    4)如何实现保留三位小数,第四位四舍五入的程序,(要求背下来)

           y=(int)(x*100+0.5)/100.0   这个保留两位,对第三位四舍五入

           y=(int)(x*1000+0.5)/1000.0 这个保留三位,对第四位四舍五入

    y=(int)(x*10000+0.5)/10000.0 这个保留四位,对第五位四舍五入

       这个有推广的意义,注意 x = (int)x 这样是把小数部分去掉。

                                     第三章

    特别要注意:C语言中是用非0表示逻辑真的,用0表示逻辑假的。

                C语言构造类型没有逻辑类型

                关系运算符号:注意<=的写法,==和=的区别!(考试重点)

                if只管后面一个语句要管多个,请用大括号

    1)关系表达式:

       a、表达式的数值只能为1(表示为真),或0(表示假)。

    如 9>8这个关系表达式是真的,所以9>8这个表达式的数值就是1。

    如 7<6这个关系表达式是假的,所以7<6这个表达式的数值就是0

       b、考试最容易错的:就是int x=1,y=0,z=2;

                              x<y<z是真还是假?带入为1<0<2,从数学的角度出发肯定是

    错的,但是如果是C语言那么就是正确的!因为要1<0为假得到0,表达式就变成

    了0<2那么运算结果就是1,称为了真的了!

       c、等号和赋值的区别!一定记住“=”就是赋值,“= =”才是等号。虽然很多人可以背

    诵,但我依然要大家一定好好记住,否则,做错了,我一定会强烈的鄙视你!

    2)逻辑表达式:

       核心:表达式的数值只能为1(表示为真),或0(表示假)。

    a)  共有&&   ||   ! 三种逻辑运算符号。

    b) !>&&>||  优先的级别。

    c)  注意短路现象。考试比较喜欢考到。详细请见书上例子,一定要会做例1和例2

    d)  表示 x 小于0大于10的方法。

    0<x<10是不行的(一定记住)。是先计算0<x 得到的结果为1或则0;再用0,或1与10比较得到的总是真(为1)。所以一定要用 (0<x)&&(x<10)表示比0大比10

    3)if 语句

      a、else 是与最接近的if且没有else的语句匹配。

      b、交换的程序写法:t=x;x=y;y=t;

      c、if(a<b)t=a;a=b;b=t;

         if(a<b){t=a;a=b;b=t;}两个的区别,考试多次考到了!

      d、单独的if语句:if(a<b)t=a;

         标准的if语句:if(a<b)min=a;

    else  min=b;

         嵌套的if语句:if(a<b)

    if(b>c)printf(“ok!”);

         多选一的if语句if(a= =t)printf(“a”);

                       else if(b= =t)printf(“b”);

                       else if(c= =t)printf(“c”);

                       else pritnf(“d”);

         通过习题,要熟悉以上几种if语句!

    经典考题:结合上面四种if语句题型做题,答错了,请自行了断!预备,开始!

    int  a=1,b=0;

    if(!a)b++;

    else if(a= =0)

    if(a)b+=2;

    else b+=3;请问b的值是多少?

    如果没有看懂题目,你千万不要自行了断,这样看得懂不会做的人才会有理由的活着。

     正确的是b为3。

    int  a=1,b=0;

    if(!a)b++;    是假的不执行

    elseif(a= =0)    是假的执行

    if(a)b+=2; 属于else if的嵌套if语句,不执行。

    elseb+=3;        if-else-if语句没有一个正确的,就执行else的语句!

    4)条件表达式:

         表达式1 ?表达式2 :表达式3

    a、考试口诀:真前假后

       b、注意是当表达式1的数值是0时,才采用表达式2的数值做为整个运算结果,当表达式1的数值0时,就用表达式3的数值做为整个的结果。

       c、int a=1,b=2,c=3,d=4,e=5;

    k=a>b?c:d>e?d:e;求k的数值时多少?  答案为san

    5)switch语句:

    a) 执行的流程一定要弄懂!上课时候详细的过程讲了,请自己一定弄懂!

    b)注意有break 和没有break的差别,书上的两个例子,没有break时候,只要有一个case匹配了,剩下的都要执行,有break则是直接跳出了swiche语句。break在C语言中就是分手,一刀两断的意思。

    c) switch只可以和break一起用,不可以和continue用。

    d) switch(x)   x:是整型常量,字符型常量,枚举型数据。

    {case 1: ….     不可以是变量。

    case 2: ….

    }

        e)switch是必考题型,请大家一定要完成书上的课后的switch的习题。

                                           第四章

    1)三种循环结构:

       a)for() ; while();  do- while()三种。

       b)for循环当中必须两个分号,千万不要忘记。

       c)写程序的时候一定要注意,循环一定要有结束的条件,否则成了死循环。

       d) do-while()循环的最后一个while();的分号一定不能够丢。(当心上机改错),do-while循环是至少执行一次循环。

    2) break 和  continue的差别

       记忆方法:

    break:是打破的意思,(破了整个循环)所以看见break就退出整个一层循环。

    continue: 是继续的意思,(继续循环运算),但是结束本次循环,就是循环体内剩下的语句不再执行,跳到循环开始,然后判断循环条件,进行新一轮的循环

    3)嵌套循环

       就是有循环里面还有循环,这种比较复杂,要一层一层一步一步耐心的计算,一般记住两层是处理二维数组的。

    4)while((c=getchar())!=’\n’) 和

    while(c=getchar() !=’\n’)的差别

    先看a = 3 != 2  和 (a=3)!=2 的区别:

    (!=号的级别高于=号 所以第一个先计算 3!=2) 第一个a的数值是得到的1;第二个a的数值是3。

    考试注意点: 括号在这里的重要性。

    5)每行输出五个的写法:

    for(i=0;i<=100;i++)

    {printf(“%d”,i);

     if((i+1)%5==0)printf(“\n”); 如果i是从1开始的话,就是if(i%5==0)printf(“\n”);

    }

    6)如何整除一个数:i%5==0表示整除5

                       I%2==0表示整除2,同时表示是偶数!

    7)输入123,输出321逆序输出数据

    int i=123;       

    while(i!=0)

    {

      printf(“%d”,i%10

    i=i/10;}

    8)for只管后面一个语句

    inti=3;

    for(i=3;i<6;i++):

    printf(“#”):                请问最终打印几个#号?答案为一个!

    9)不停的输入,直到输入# 停止输入!      不停的输入,直到输入$停止输入!

        while( (x=getchar())!=’ # ’ )                 while( (x=getchar())!=’$ ’ )

    不停的输入,直到遇到?停止输入!

    while((x=getchar())!=’ ? ’)   解说:一定要注意这种给出了条件,然后如何去写的方法!  

    10)for循环和switch语句的和在一起考题!   

    11)多次出现的考题

    intk=1                       int k=1;

    while(- -k);                while(k--);

    printf(“%d”,k);           printf(“%d”,k);    

    结果为0                     结果为-1

    第五章

    1、函数:是具有一定功能的一个程序块,是C语言的基本组成单位。

    2、函数不可以嵌套定义。但是可以嵌套调用。

    3、函数名缺省返回值类型,默认为 int。

    4、C语言由函数组成,但有且仅有一个main函数!是程序运行的开始!

    5、如何判断a是否为质数:背诵这个程序!

    void  iszhishu( int a )

    {  for(i=2;i<a/2;i++)

        if(a%i==0) printf(“不是质数”);

       printf(“是质数!”);

    }

    6、如何求阶层n! 背诵这个程序!

       int fun(int n)

    {  int p=1;

    for(i=1;i<=n;i++) p=p*i;

    return p;

    }

    7、函数的参数可以是常量,变量,表达式,甚至是函数调用

      add(int x,int y){returnx+y;}

      main()

    { int sum;

     sum=add(add(7,8),9);请问sum的结果是多少? 结果为24

    }

    8、 函数的参数,返回数值(示意图):


    9、一定要注意参数之间的传递

       实参和形参之间 传数值,和传地址的差别。(考试的重点)

          传数值的话,形参的变化不会改变实参的变化。

          传地址的话,形参的变化就会有可能改变实参的变化。

    10、函数声明的考查:

    一定要有:函数名,函数的返回类型,函数的参数类型。不一定要有:形参的名称

    填空题也可能会考到!以下是终极难度的考题。打横线是函数声明怎么写!

    int*fun(int a[] , int b[])             

    {

    …………..

    }已经知道函数是这样。这个函数的正确的函数声明怎么写?

    int *fun(int *a , int *b)               这里是函数声明的写法,注意数组就是指针

    int *fun(int a[] , int b[])              这种写法也是正确的                      

    int *fun(int b[] , int c[])              这种写法也是正确的,参数的名称可以随便写

    int *fun(int * , int *)                这种写法也是正确的,参数的名称可以不写 

    11、要求掌握的库函数:

        a、库函数是已经写好了函数,放在仓库中,我们只需要如何去使用就可以了!   

    b、以下这些库函数经常考到,所以要背诵下来。

    abs()、 sqrt()、fabs()、pow()、sin()  其中pow(a,b)是重点。23是由pow(2,3)表示的。

     

    第六章

    指针一定要初始化NULL

    动态存储

       #include<malloc>  int *p

    P=(int*)malloc(sizeof(int)*n)

    指针变量的本质是用来放地址,而一般的变量是放数值的。

    1、int *p 中   *p和p的差别:简单说*p是数值,p是地址!

    *p可以当做变量来用;*的作用是取后面地址p里面的数值

     p是当作地址来使用。可以用在scanf函数中:scanf(“%d”,p);

     

    2、*p++ 和 (*p)++的之间的差别:改错题目中很重要!考试超级重点

             *p++是 地址会变化。      口诀:取当前值,然后再移动地址!

             (*p)++ 是数值会要变化。 口诀:取当前值,然后再使数值增加1。   

    例题:int *p,a[]={1,3,5,7,9};

          p=a;

          请问*p++和(*p)++的数值分别为多少?

          *p++:  这个本身的数值为1。由于是地址会增加一,所以指针指向数值3了。 

    (*p)++ 这个本身的数值为1。由于有个++表示数值会增加,指针不移动,但数值1由于自加了一次变成了2。      

    3、二级指针:

      *p:一级指针:存放变量的地址。

      **q:二级指针:存放一级指针的地址。

      常考题目:   int x=7;

                   int*p=&x,**q=p;

                   问你:*p为多少?*q为多少?**q为多少?

                           7          p         7

                   再问你:**q=&x的写法可以吗?  

                          不可以,因为二级指针只能存放一级指针的地址。

    4、三名主义:(考试的重点)

       数组名:表示第一个元素的地址。数组名不可以自加,他是地址常量名。(考了很多次)

       函数名:表示该函数的入口地址。

       字符串常量名:表示第一个字符的地址。

    5、移动指针(经常加入到考试中其他题目综合考试)

      char *s=“meikanshu”  

    while(*s){printf(“%c”,*s);s++;}

    这个s首先会指向第一个字母m然后通过循环会一次打印出一个字符,s++是地址移动,打印了一个字母后,就会移动到下一个字母!

    6指针变量两种初始化(一定要看懂)

    方法一:int a=2,*p=&a;(定义的同时初始化)

    方法二:int a=2,*p;  (定义之后初始化)

        p=&a;

    7传数值和传地址(每年必考好多题目)

    void fun(int a,intb)                    void fun(int *a,int *b)            

    { int t ;                                       { int t ;

      t=a;a=b;b=t;                                  t=*a;*a=*b;*b=t;

    }                                               }

    main()                                     main()

    { int x=1,y=3,                             { int x=1,y=3,

      fun(x,y);                                 fun(&x,&y)

      printf(“%d,%d”,x,y);                    printf(“%d,%d”,x,y);

    }                                             }

    这个题目答案是1和3。                        这个题目的答案就是3和1。

    传数值,fun是用变量接受,所以fun中     传地址,fun用指针接受!这个时候fun

    的交换不会影响到main中的x和y 。        中的交换,就会影响到main中的x和y。

    传数值,形参的变化不会影响实参。          传地址形参的变化绝大多数会影响到实参!

     

    8、函数返回值是地址,一定注意这个*号(上机考试重点)  

    int *fun(int*a,int *b)   可以发现函数前面有个*,这个就说明函数运算结果是地址                            

    { if(*a>*b)returna;     return a 可以知道返回的是a地址。

      else return b;                                                                        

    }

    main()

    { int x=7,y=8,*max;

      max = fun(&x,&y);      由于fun(&x,&y)的运算结果是地址,所以用max来接收。

      printf(“%d,%d”,)   

    }                                             

    9、考试重要的话语:

    指针变量是存放地址的。并且指向哪个就等价哪个,所有出现*p的地方都可以用它等价的代替。例如:int a=2,*p=&a;

        *p=*p+2;

    (由于*p指向变量a,所以指向哪个就等价哪个,这里*p等价于a,可以相当于是a=a+2) 

     

     

    第七章

    数组: 存放的类型是一致的。多个数组元素的地址是连续的。

    1、一维数组的初始化:

    inta[5]={1,2,3,4,5};  合法

    inta[5]={1,2,3, };    合法

    inta[]={1,2,3,4,5};   合法,常考,后面决定前面的大小!

    inta[5]={1,2,3,4,5,6};不合法,赋值的个数多余数组的个数了

    2、一维数组的定义;

    int a[5];注意这个地方有一个重要考点,定义时数组的个数不是变量一定是常量。

    int a[5]                 合法,最正常的数组

    int a[1+1]               合法,个数是常量2,是个算术表达式

    int a[1/2+4]             合法,同样是算术表达式

    int x=5,int a[x];           不合法,因为个数是x,是个变量,非法的,

    define P 5  int a[P]       合法,define 后的的P是符号常量,只是长得像变量

    3、二维数组的初始化

    inta[2][3]={1,2,3,4,5,6};               合法,很标准的二维的赋值。

    inta[2][3]={1,2,3,4,5, };                合法,后面一个默认为0

    inta[2][3]={{1,2,3,} {4,5,6}};           合法,每行三个。

    inta[2][3]={{1,2,}{3,4,5}};             合法,第一行最后一个默认为0

    inta[2][3]={1,2,3,4,5,6,7};              不合法,赋值的个数多余数组的个数了。

    int a[2][]={1,2,3,4,5,6};                不合法,不可以缺省列的个数。

    int a[][3]={1,2,3,4,5,6};                合法,可以缺省行的个数

    补充:

    1)一维数组的重要概念:

    对a[10]这个数组的讨论。

    1、a表示数组名,是第一个元素的地址,也就是元素a[0]的地址。(等价于&a

    2、a是地址常量,所以只要出现a++,或者是a=a+2赋值的都是错误的。

    3、a是一维数组名,所以它是列指针,也就是说a+1跳一列。 

    对a[3][3]的讨论。

    1、a表示数组名,是第一个元素的地址,也就是元素a[0][0]的地址。

    2、a是地址常量,所以只要出现a++,或者是a=a+2赋值的都是错误的。

    3、a是二维数组名,所以它是行指针,也就是说a+1跳一行

    4、a[0]、a[1]、a[2]也都是地址常量,不可以对它进行赋值操作,同时它们都是列指针,a[0]+1,a[1]+1,a[2]+1都是跳一列。

    5、注意a和a[0] 、a[1]、a[2]是不同的,它们的基类型是不同的。前者是一行元素,后三者是一列元素。

    2) 二维数组做题目的技巧:

    如果有a[3][3]={1,2,3,4,5,6,7,8,9}这样的题目。

    步骤一:把他们写成:      第一列 第二列 第三列  

    a[0]à  1    2    3   ->第一行

    a[1]à   4     5    6  —>第二行

    a[2]à   7     8    9  ->第三行

    步骤二:这样作题目间很简单:    

    *(a[0]+1)我们就知道是第一行的第一个元素往后面跳一列,那么这里就是a[0][1]元素,所以是1。

    *(a[1]+2)我们就知道是第二行的第一个元素往后面跳二列。那么这里就是a[1][2]元素,所以是6。

    一定记住:只要是二维数组的题目,一定是写成如上的格式,再去做题目,这样会比较简单。

    3) 数组的初始化,一维和二维的,一维可以不写,二维第二个一定要写

         int a[]={1,2} 合法。  int a[][4]={2,3,4}合法。  但int a[4][]={2,3,4}合法。

    4) 二维数组中的行指针

     int a[1][2]; 

    其中a现在就是一个行指针,a+1跳一行数组元素。  搭配(*)p[2]指针

         a[0],a[1]现在就是一个列指针。a[0]+1 跳一个数组元素。搭配*p[2]指针数组使用

    5) 还有记住脱衣服法则:超级无敌重要

       a[2]  变成   *(a+2)  a[2][3]变成 *(a+2)[3]再可以变成  *(*(a+2)+3)

    这个思想很重要!

     

     

    其它考试重点

    文件的复习方法

    把上课时候讲的文件这一章的题目要做一遍,一定要做,基本上考试的都会在练习当中。

    1)字符串的 strlen() 和 strcat() 和strcmp() 和strcpy()的使用方法一定要记住。他们的参数都是地址。其中strcat()和strcmp()有两个参数。

     

    2)strlen 和 sizeof的区别也是考试的重点;

     

    3)define  f(x)(x*x)  和  define   f(x) x*x 之间的差别。一定要好好的注意这写容易错的地方,替换的时候有括号和没有括号是很大的区别。

     

    4)int  *p

    p= (int *)malloc(4);

    p= (int *)malloc(sizeof(int));以上两个等价

    当心填空题目,malloc的返回类型是 void *

     

    6)函数的递归调用一定要记得有结束的条件,并且要会算简单的递归题目。要会作递归的题目

     

    7)结构体和共用体以及链表要掌握最简单的。typedef考的很多,而且一定要知道如何引用结构体中的各个变量,链表中如何填加和删除节点,以及何如构成一个简单的链表,一定记住链表中的节点是有两个域,一个放数值,一个放指针。

              内存计算

                      结构体                      共用体

                         Int 4char1double8     

    总内存 16 (最大内存为单位,存不下再开辟一个单元) 8(最大内存为单位,不停迭代) 

    结构体成员:结构体变量.成员 *p.成员  p->成员名

    成员为数组时输入不用&其他都要只能对最低一级成员操作

    strcut 结构体{成员类型成员名}变量名列表 可以嵌套使用

    链表及动态链表  在成员中加个指针

    8)函数指针的用法(*f)()记住一个例子:

          int add(int x, int y)

    {....}

     main()

    { int  (*f)();

      f=add;

     }

    赋值之后:合法的调用形式为1、add(2,3);

    2、f(2,3);

    3、(*f)(2,3)

    9)两种重要的数组长度:

    char a[]={‘a’,’b’,’c’};  数组长度为3,字符串长度不定。sizeof(a)为3。

    char a[5]={ ‘a’,’b’,’c’}  数组长度为5,字符串长度3。sizeof(a)为5。

    10)scanf 和 gets的数据:

    如果输入的是 good  good study!

    那么scanf(“%s”,a); 只会接收 good. 考点:不可以接收空格。

         gets(a); 会接收 good good study! 考点:可以接收空格。

    11)共用体的考查:

    union TT

    { int a;

    charch[2];}

    考点一: sizeof (struct TT) = 4;

    12)“文件包含”的考查点:

           no1.c                  no2.c

    #include”no2.c”

    main()

    { add(29 , 33);

     …….

    }

     

    int add(int a,int b)

    {

    return a+b;

    }

     

     

     

     

     

     


    这里一个C语言程序是有两个文件组成,分别是no1.c, no2.c。那么no1.c中最开始有个#include”no2.c”他表示把第二个文件的内容给包含过来,那么no1.c中调用add()函数的时候就可以了把数值传到no2.c中的被调用函数add()了。

    一个文件必须要有main函数。 这句话错了。 例如:no2.c就没有。

    头文件一定是以.h结束的。 这句话错了。例如:no1.c中就是#include”no2.c”以.c结尾的。

    13)指针迷惑的考点:

    char ch[]=”iamhandsome”;

    char *p=ch;

    问你 *(p+2) 和 *p+2的结果是多少?

          ‘m’       ‘k’  结果是这两个,想不通的同学请作死的想!想通为止!

    14)数组中放数组一定要看懂:

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

       int b[5]={0};

       b[a[3]]++   这个写法要看懂,结果要知道是什么?b[4]++,本身是0,运行完后,b[4]为1了。

    15)字符串的赋值

      C语言中没有字符串变量,所以用数组和指针存放字符串:

    1、char  ch[10]={“abcdefgh”};                       对

    2、char  ch[10]=“abcdefgh”;                         对

    3、char  ch[10]={‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’};           对

    4、char  *p=“abcdefgh”;                            对

    5、char  *p;                                     对

    p=“abcdefgh”;

    6、char  ch[10];                    错了!数组名不可以赋值!

              ch=“abcdefgh”;

    7、char  *p={“abcdefgh”};           错了!不能够出现大括号!

    16)字符串赋值的函数背诵:一定要背诵,当心笔试填空题目。

      把s指针中的字符串复制到t指针中的方法

      1、while( (*t=*s)!=null){s++;t++;}  完整版本

      2、while( *t=*s ){s++;t++;}           简单版本

      3、while( *t++=*s++);                   高级版本

    17)typedef 是取别名,不会产生新的类型,他同时也是关键字

    考点一:typedef int qq  那么 int x 就可以写成 qq x

    考点二:typedef int *qq  那么 int *x就可以写成 qq x

    18)static 考点是一定会考的!复习相关的习题。

    static int x;默认值为0。

    int x:默认值为不定值。

    19)函数的递归调用一定会考!至少是2分。

    常用知识点补充

    运算符

    1.   优先级

       

    2.   结合方向

             自右向左:单目运算符,条件运算符,赋值运算符。

    展开全文
  • 二级C语言考试知识点(很全)

    万次阅读 多人点赞 2018-11-30 01:38:14
    二级公共基础知识作为必考内容出现,出题形式为选择题前10道,占考试总分的10%。 考试其它比重: 1、C语言程序的结构 占总分1% 2、数据类型及其运算 占总分4% 3、选择结构程序设计 占比分的3% 4、循环结构 占比分的5...

    二级公共基础知识作为必考内容出现,出题形式为选择题前10道,占考试总分的10%。
    考试其它比重:
    1、C语言程序的结构 占总分1%
    2、数据类型及其运算 占总分4%
    3、选择结构程序设计 占比分的3%
    4、循环结构 占比分的5%
    5、数组的定义和引用 占比分的5%
    6、函数 占比分的5%
    7、编译预处理 占比分1%
    8、指针 占比分的5%
    9、结构体 占比分的3%
    10、位运算 占比分的2%
    11、文件操作 占比分的2%
    考试方式
    上机考试,时长120分钟
    单选题40分(含公共基础10分),操作题60分(包括程序填空题、程序修改题、程序设计题)

    第一部分 C语言知识复习资料

    第一章 C语言基本知识(90分)
    【考点1】C程序
    用C语言编写的程序称为C语言源程序,源程序文件的后缀名为“.c”。源程序经编译后生成后缀名为“.obj”的目标文件,再把目标文件与各种库函数连接起来,生成“.exe”可执行文件。C语言有三种基本结构:顺序结构、选择结构、循环结构。
    【考点2】main函数
    又称主函数,是C程序的入口。main后面跟一对小括号和一对花括号,花括号括起来的部分称为main函数的函数体。一个C程序从main函数开始执行,到main函数体执行完结束,而不论main函数在整个程序中的位置如何。每一个程序有且仅有一个main函数,其他函数都是为main函数服务的。
    【考点3】存储形式
    计算机在电脑中保存数据是采用二进制形式,由0或1构成的二进制称为位(bit),八个位构成一个字节(Byte),1个Byte=8个bit。二进制、八进制、十六进制转化为十进制采用乘法,十进制转化为二进制、八进制、十六进制采用除法。数据的存放位置就是它的地址。
    【考点4】注释
    是对程序的说明,可出现在程序中任意合适的地方,注释从“/”开始到最近一个“/”结束,其间任何内容都不会被计算机执行,注释不可以嵌套。
    【考点5】书写格式
    每条语句的后面必须有一个分号,分号是语句的一部分。一行内可写多条语句,一个语句可写在多行上。
    【考点6】标识符
    是标识名字的有效字符序列,可以理解为C程序中的单词。
    标识符的命名规则是:
    (1)标识符只能由字母、数字和下划线组成,字母区分大小写。
    (2)标识符的第一个字符必须是字母或下划线,不能为数字。
    C语言标识符分如下3类
    (1)关键字。它们在程序中有固定的含义,不能另作他用。如int、for、switch等。
    (2)预定义标识符。预先定义并具有特定含义的标识符。如define、include等。
    (3)用户标识符。用户根据需要定义的标识符,符合命名规则且不与关键字相同。
    【考点7】常量与变量
    常量是指在程序运行过程中,其值不能改变的量。常量分为整型常量、实型常量、字符常量、字符串常量、符号常量5种。在程序运行过程中其值可以改变的量称为变量。C语言中没有字符串变量。存放字符串使用字符数组。
    【考点8】整型数据
    整型常量有十进制、八进制、十六进制三种表示形式,没有二进制形式。八进制整型常量加前导数字0,十六进制常量加前导0X,八进制常量中不会出现8。
    整型变量可分为基本整型(int)、短整型(short)、长整型(long)、和无符号整型(unsigned)。一个基本整型占4个字节。其它类型的整型占用字节数和取值范围详见教材第9页。
    【考点9】实型数据
    实型数据有两种表示形式:小数形式和指数形式。掌握判定指数形式合法性。
    口诀:E前E后必有数,E后必须为整数。
    实型变量分为单精度型(float)和双精度型(double),单精度型占四个字节。
    【考点10】算术运算
    算术运算符一共有+、—、*、/、%这五个。求余运算要求运算对象只能为整型,除法运算符两边运算对象都为整型时,运算结果也为整型即舍掉小数部分。
    【考点11】强制类型转换
    将一个运算对象转换成指定类型,格式为(类型名)表达式,注意小括号位置。
    【考点12】赋值
    赋值运算符为“=”,不同于关系等于“= =”。赋值表达式格式为:变量名=表达式,赋值运算符左边必须为变量,赋值运算是把赋值运算符右边表达式的值赋给左边变量。
    复合赋值运算符是将算术运算符或位运算符与赋值运算符组合在一起组成的运算符,掌握复合赋值表达式转化为赋值表达式的方法。如n+=100可转化为n=n+100。

    【考点13】自加自减运算
    自加运算符“++”与自减运算符“- -”是单目运算符,运算对象必须是变量。自增自减运算分前缀运算和后缀运算,它们所对应的表达式的值是有区别的,如j=i++;等价于j=i;i=i+1;而j=++i;等价于i=i+1;j=i;。
    口诀:加加在前先加后用,加加在后先用后加。
    【考点14】逗号运算
    逗号运算符运算优先级最低,可将多个表达式构成一个新的表达式。
    考试真题:
    1、下列叙述中错误的是( D )——2006年4月选择第44题
    A)C语言源程序经编译后生成后缀为.obj的目标程序
    B)C语言经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件
    C)用C语言编写的程序称为源程序,它以ASCII代码形式存放在一个文本文件中
    D)C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令

    2、下列叙述中错误的是(B)——2006年4月选择第45题
    A)算法正确的程序最终一定会结束
    B)算法正确的程序可以有零个输出
    C)算法正确的程序可以有零个输入
    D)算法正确的程序对于相同的输入一定有相同的结果

    3、下列叙述中错误的是(A)——2006年9月选择第11题
    A)一个C语言程序只能实现一种算法
    B)C程序可以由多个程序文件组成
    C)C程序可以由一个或多个函数组成
    D)一个C函数可以单独作为一个C程序文件存在

    4、下列叙述中正确的是(D)——2006年9月选择第12题
    A)每个C程序文件中都必须要有一个main()函数 算法正确的程序对于相同的输入一定有相同的结果
    B)在C程序中main()函数的位置是固定的
    C)C程序中所有函数之间都可以相互调用,与函数所处位置无关
    D)在C程序的函数中不能定义另一个函数

    5、在算法中,对需要执行的每一步操作,必须给出清楚、严格的规定,这属于算法的(C)——2007年4月选择第11题
    A)正当性
    B)可行性
    C)确定性
    D)有穷性

    6、下列叙述中错误的是(D)——2007年4月选择第12题
    A)计算机不能直接执行用C语言编写的源程序
    B)C程序经C编译程序编译后,生成后缀为.obj的文件是一个二进制文件
    C)后缀为.obj的文件,经连接程序生成后缀为.exe的文件是一个二进制文件
    D)后缀为.obj和.exe的二进制文件都可以直接运行

    7、下列叙述中错误的是(C)——2007年4月选择第14题
    A)C语言是一种结构化程序设计语言
    B)结构化程序由顺序、分支、循环3种基本结构组成
    C)使用3种基本结构构成的程序只能解决简单问题
    D)结构化程序设计提倡模块化的设计方法

    8、对于一个正常运行的C程序,下列叙述中正确的是(A)—2007年4月选择第15题
    A)程序的执行总是从main函数开始,在main函数结束
    B)程序的执行总是从程序的第一个函数开始,在main函数结束
    C)程序的执行总是从main函数开始,在程序的最后一个函数中结束
    D)程序的执行总是从程序中的第一个函数开始,在程序的最后一个函数结束

    9、C语言源程序名的后缀是(B)——2007年9月选择第11题
    A).exe B).c C).obj D).cp
    10、下列叙述中正确的是(C)——2007年9月选择第14题
    A)C语言程序将从源程序中第一个函数开始执行
    B)可以在程序中由用户指定任意一个函数作为主函数,程序将从此开始执行
    C)C语言规定必须用main作为主函数名,程序将从此开始执行,在此结束
    D)Main可作为用户标识符,用以命名任意一个函数作为主函数

    1. 以下选项中合法的标识符是(2009年3月)(C)
      A)1_1 B)1-1 C)11 D)1 2.
      2、以下选项中不合法的标识符是c(2008年4月)
      A)print B)FOR C)&a D)_00

    2. 可在C程序中用做用户标识符的一组标识符是(2007年9月)
      A)and B)Date C)Hi D)case _2007 y-m-d Dr.Tom Bigl

    3. 按照C语言规定的用户标识符命名规则,不能出现在标识符中的是 (B)(2007年4月)
      A)大写字母 B)连接符 C)数字字符 D)下划线

    4. 以下不合法的用户标识符是(C)(2006年4月)
      A)j2_KEY B)Double C) 4d D) 8

    5. 以下选项中不属于字符常量的是(2008年4月)
      A)‘C’ B)“C” C)’\xCC0’ D)’\072’

    6. 以下合法的字符常量的是 (A)
      A)’\x 13’ B)‟\081‟ C)‘65’ D)”\n”

    7. 已知大写字母A的ASCII码是65,小写字母a的ASCII码是97。下列不能将变量c中
      的大写字母转换为对应小写字母的语句是(2007年4月) (D)
      A)c=(c-„ A‟)%26+‟a‟
      B) B)c=c+32
      C)C)c=c-„A‟ +‟a‟
      D) D)c=(„A‟+c)%26-„a‟

    8. 以下选项中,值为1的表达式________。(2006年9月)
      A)1-„0‟ B)1-„\0‟ C)‟1‟-0 D)‟\0‟-„0‟ 1.

    5.以下选项中,能用作数据常量的是(2009年3月)
    A)o115 B)0118 C)1.5e1.5 D) 115L

    6、以下选项中不能作为C 语言合法常量的是( )。
    A)‘cd’ B)0.1e+6 C)"\a" D)’\011’

    1. 以下不合法的数值常量是 (B)
      A)011 B)lel C)8.0 E0.5 D)0xabcd

    2. C 源程序中不能表示的数制是(A)。(2008年9月)
      A)二进制
      B)八进制
      C)十进制
      D)十六进制

    3. 以下关于long、int和short类型数据占用内存大小的叙述中正确的是(2007年9月) (D)
      A)均占4个字节
      B)根据数据的大小来决定所占内存的字节数
      C)由用户自己定义
      D)由C语言编译系统决定

    4. 以下选项中,合法的一组C语言数值常量是(2007年9月)
      A) 028
      B) 12.
      C) .177
      D) 0x8A
      . 5e-3
      0xa23
      4e1.5

    10,000
    -0xf 4.5e0 0abc 3.e5

    第二章顺序结构

    【考点1】运算符、表达式、语句
    运算对象加运算符构成表达式,表达式加分号构成表达式语句,运算对象可以是表达式、常量、变量。如赋值运算符加运算对象构成赋值表达式,赋值表达式加分号又可构成赋值语句。
    【考点2】运算符的优先级和结合顺序
    运算符按参加运算的对象数目可分为单目运算符、双目运算符和三目运算符。初等运算符的优先级别最高,然后依次是单目运算符、算术运算符、关系运算符、逻辑运算符(除逻辑非!)、条件运算符、赋值运算符、逗号运算符。位运算符优先级介于算术运算符与逻辑运算符之间。结合顺序大多为自左向右,而自右向左的有三个:单目运算符、条件运算符和赋值运算符。
    【考点3】printf函数
    格式为:printf(输出控制,输出列表)。输出控制是用一对双引号括起来的,包含格式说明和原样信息。输出列表包含若干输出项。
    【考点4】printf函数中格式说明
    %d对应整型,%f对应单精度实型,%c对应字符型,%o对应八进制无符号整型,%x对应无符号十六进制整型,%u对应无符号整型,%e对应指数型,%s对应字符串型。可在%和格式字符之间加一个数来控制数据所占的宽度和小数位数。
    【考点5】scanf函数
    输入项要求带取地址符&。当用键盘输入多个数据时,数据之间用分隔符。分隔符包括空格符、制表符和回车符,但不包括逗号。
    【考点】6如何交换两个变量
    要使用中间变量,语句为:t=x; x=y; x=t;。

    第三章 选择结构

    【考点1】关系运算
    C语言用非0表示逻辑真,用0表示逻辑假。关系运算符有6个,分别是>,>=,<,<=,==,!=,前四种优先级高于后两种。关系表达式真时为1,假时为0。注意a<b<c是不可以的,可用(a<b)&&(b<c)来表示。
    【考点2】逻辑运算
    逻辑运算符共有3个:逻辑与(&&),逻辑或(||),逻辑非(!)。注意短路现象,例a++||b++,如果表达式a++的值非零,则表达式b++不再执行。
    【考点3】if语句
    可以单独出现,也可以与else匹配出现。if语句可以嵌套,这时else总是与离它最近的且没有与else匹配的if匹配。
    【考点4】条件运算
    是唯一的三目运算符,格式为:表达式1?表达式2:表达式3。表达式1值为非0时,整个表达式值为表达式2的值,表达式1值为0时,整个表达式值为表达式3的值。
    口诀:真前假后
    【考点5】switch语句
    格式及执行过程详见教材P33,要注意每条case后有没有break语句的区别。还要注意switch后小括号里面的表达式不能为实型,case后表达式不能有变量。
    口诀:switch表不为实,case表不为变。

    第四章 循环结构

    【考点1】三种循环结构
    三种循环结构分别为:while,do-while,for,三种结构的格式及执行顺序详见教材第36、39、40页。注意for循环中的小括号中必须是两个分号;循环一定要有结束条件,否则成了死循环;do-while()循环最后的while();后一定要有分号。
    【考点2】break与continue
    break是终止所在整个循环,而continue是提前结束本轮循环。break语句可出现在循环结构与switch语句中,continue只出现在循环结构中。
    【考点3】循环的嵌套
    就是循环里面还有循环,计算要一层一层分析,一般只考查两层嵌套,循环嵌套通常是处理二维数组。
    【考点4】循环结构的复习
    循环结构是重点,笔试所占分值一般在13分左右,在上机考试中也是必考点,应用性很强。要求学员重点理解并多加练习,领会掌握。

    第五章 字符型数据 位运算

    【考点1】字符常量
    一个字符常量用一对单引号括起来,字符常量只能包括一个字符,’ab’是非法的。空格常用’□’来表示。字符常量可用对应的ASCII码表示,需记住:’0’的ASCII码为48,’A’的ASCII码为65,’a’的ASCII码为97。
    【考点2】转义字符
    一对单引号中以一个反斜线后跟一个特定字符或八进制、十六进制数来构成转义字符。比如’\n’表示换行,’\101’或’\x41’表示ASCII码为65的字符’A’。
    【考点3】字符型数据可以和整型数据相互转换
    如:’0’-0=48 ‘A’+32=’a’ char a=65;printf(“%d%c”,a,a);结果为65A
    【考点4】位运算符
    C语言提供6种位运算符:按位求反~,按位左移<<,按位右移>>,按位与&,按位异或|,按位或^。一般情况下需要先转化进制。异或运算的规则:0异或1得到1,0异或0得到0,1异或1得到0。可记为“相同为0,不同为1”。
    【考点5】putchar与getchar函数
    可用于输出或输入单个字符,这两个函数是stdio.h文件中的库函数,它们是printf与scanf函数的简化。

    第六章 函数

    【考点1】函数的定义
    函数是具有一定功能的一个程序块。函数的首部为:函数类型 函数名(类型1 形参1,类型2 形参2,……)。在函数定义中不可以再定义函数,即不能嵌套定义函数。函数类型默认为int型。
    【考点2】库函数
    调用C语言标准库函数时要包含include命令,include命令行以#开头,后面是””或<>括起来的后缀为”.h”的头文件。以#开头的一行称为编译预处理命令行,编译预处理不是C语言语句,不加分号,不占运行时间。
    【考点3】函数的返回值
    函数通过return语句返回一个值,返回的值类型与函数类型一样。return语句只执行一次,执行完或函数体结束后退出函数。
    【考点4】函数的声明
    函数要“先定义后调用”,或“先声明再调用后定义”。函数的声明一定要有函数名、函数返回值类型、函数参数类型,但不一定要有形参的名称。
    【考点5】函数的调用
    程序从上往下执行,当碰到函数名后,把值传给调用函数,当程序得到了返回值或调用函数结束,再顺序往下执行。
    【考点6】函数的参数及值传递
    形式参数简称形参,是定义函数时函数名后面括号中的参数。实在参数简称实参,是调用函数时函数名后面括号中的参数。实参和形参分别占据不同的存储单元。实参向形参单向传递数值。
    “传值”与“传址”的区别:传数值的话, 形参的变化不会改变实参的变化。传地址的话,形参的变化就有可能改变实参所对应的量。
    【考点7】函数的递归调用
    函数直接或间接地调用自己称为函数的递归调用。递归调用必须有一个明确的结束递归的条件。在做递归题时可把递归的步骤一步步写下来,不要弄颠倒了。
    【考点8】要求掌握的库函数
    sqrt()算术平方根函数,fabs()绝对值函数,pow()幂函数,sin()正弦函数
    第七章 指针
    【考点1】指针变量
    【考点2】指针变量的定义指针变量是用来存储地址的,而一般变量是存储数值的。指针变量可指向任意一种数据类型,但不管它指向的数据占用多少字节,一个指针变量占用四个字节。

    格式为:类型名 *指针变量名。二维指针int **p;可以理解为基类型为(int *)类型。
    【考点3】指针变量的初始化
    指针变量在使用前必须要初始化,把一个具体的地址赋给它,否则引用时会有副作用,如果不指向任何数据就赋“空值”NULL。
    【考点4】指针变量的引用
    &是取地址符,*是间接访问运算符,它们是互逆的两个运算符。在指针变量名前加间接访问运算符就等价它所指向的量。
    【考点5】指针的运算
    *p++和(*p)++之间的差别:*p++是地址变化,(*p)++是指针变量所指的数据变化。一个指针变量加一个整数不是简单的数学相加,而是连续移动若干地址。当两个指针指向同一数组时,它们可以比较大小进行减法运算。

    第八章 数组

    【考点1】数组的定义
    数组是一组具有相同类型的数据的集合,这些数据称为数组元素。格式为:类型名 数组名[常量表达式]。数组的所占字节数为元素个数与基类型所占字节数的乘积。
    【考点2】数组的初始化
    第一维长度可以不写,其它维必须写。int a[]={1,2};合法,int a[][3]={2,3,4};合法,int a[2][]={2,3,4};非法。数组初始化元素值默认为0,没有初始化元素值为随机。如在int a[5]={0,1,2};中,元素a[4]值为0;而在int a[5];中,元素a[4]值为一个不确定的随机数。
    【考点3】元素的引用
    数组元素的下标从0开始,到数组长度减1结束。所以int a[5];中数组最后一个元素是a[4]。要把数组元素看作一个整体,可以把a[4]当作一个整型变量。
    【考点4】二维数组
    数组a[2][3]={1,2,3,4,5,6};中含6个元素,有2行3列。第一行为a[0]行,第2行为a[1]行,a[0]、a[1]叫行首地址,是地址常量。(a[0]+1)是第一行第一个元素往后跳一列,即元素a[0][1]值为2,(a[0]+3)是第一行第一个元素往后跳三个,即元素a[1][0]值为4。
    【考点5】行指针
    是一个指针变量,占四个字节,行指针指向一行连续数据,形式为:int (p)[2];,p只能存放含有两个整型元素的一维数组的首地址。注意(p)两边的小括号不能省略,否则就成了指针数组,是若干指针元素的集合。
    【考点6】数组名
    数组名是数组的首地址。数组名不能单独引用,不能通过一个数组名代表全部元素。数组名是地址常量,不能对数组名赋值,所以a++是错误的。但数组名可以作为地址与一个整数相加得到一个新地址。
    【考点7】元素形式的转换
    助记:“脱衣服法则”a[2]变成
    (a+2),a[2][3]变成
    (a+2)[3]再可变成*(*(a+2)+3)。

    第九章 字符串

    【考点1】字符串常量及表示
    字符串常量是由双引号括起来的一串字符,如”ABC”。在存储字符串时,系统会自动在其尾部加上一个空值’\0’,空值也要占用一个字节,也就是字符串”ABC”需要占四个字节。
    【考点2】字符数组
    C语言没有字符串变量,只能采用字符数组来存储字符串。数组的大小应该比它将要实际存放的最长字符串多一个元素,从而存放’\0’。
    【考点3】字符串赋值
    可以用下面的形式进行赋值:char str[]=”Hello!”;或char *p;p=”Hello!”;,但不能用下面的形式:char str[10];str=”Hello”;因为str是一个地址常量,不能进行赋值操作。
    【考点4】字符串的输入与输出
    可以用scanf和printf函数,如scanf(”%s”,str);,也可用专门处理字符串的两个函数gets和puts函数,还可以对字符数组逐个元素进行赋值,但一定要在最后赋一个’\0’。使用gets函数可以接收空格,使用puts函数在最后输出一个换行。
    【考点5】字符串函数
    要掌握的四个字符串函数:字符串拷贝函数strcpy(),求字符串长度函数strlen(),字符串链接函数strcat(),字符串比较函数strcmp()。使用这些函数需在预处理部分包含头文件”string.h”。
    字符串长度要小于字符数组的长度,例:char str[10]=”Hello”;sizeof(str)的值为10(数组长度),strlen(str)的值为5(字符串长度)。这些函数是考试常用到的函数,大家一定要熟练应用这几个函数。

    第十章 结构体与共用体

    【考点1】结构体类型的说明
    结构体是若干个类型数据的集合,结构体类型说明格式如下:struct 类型名 {类型1 成员名1;类型2 成员名2;……};,以上整个部分是一个数据类型,与整型的int是同样地位。可用typedef把结构体类型替换成一个只有几个字母的简短标识符。
    【考点2】结构体变量的定义
    结构体变量是用说明的结构体类型所定义的一个变量,与结构体类型不是一回事。一个结构体变量所占字节数为其所有成员所占字节数之和。如struct stu{char name[10];int age;} a,b;则表明定义了两个结构体变量a,b,每个变量占4个字节。a,b与int i,j;中的变量i,j是同样地位。
    【考点3】结构体成员的引用
    引用成员可用以下3种方式:(1结构体变量名.成员名;(2)指针变量名->成员名:(3)(*指针变量名).成员名。点(.)称为成员运算符,箭头(->)称为结构指向运)
    【考点4】链表
    链表是由一个个结点构成的,一个结点就是一个结构体变量。每个结点可以分为数据域与指针域两个部分,数据域用来存放要存储的数据,指针域用来指向下一个结点。链表是考试中的难点,在C语言和公共基础部分都会考到,要领悟掌握。
    【考点5】共用体
    共用体的使用格式与结构体相似,共用体定义的关键字为union,共用体所占字节数是所有成员中字节数最大的那个。

    第十一章 文件

    【考点1】文件类型指针
    文件指针是一个指向结构体类型的指针,定义格式为:FILE *指针变量名。在使用文件时,都需要先定义文件指针。
    【考点2】文本文件与二进制文件
    文本形式存放的是字符的ASCII码,二进制形式存放的是数据的二进制。例如“100”如果是文本形式就是存储’1’、 ’0’、 ’0’三个字符的ASCII码(00110001 00110000 00110000),如果是二进制形式就把100转化成二进制(01100100)。
    【考点3】打开文件
    文件的打开形式如下:FILE *fp; fp=fopen(“c:\lab.c”,”rb”);。fopen函数的前面一部分为文件名,后面一部分为文件的使用方式。打开方式详见教材第127页,其中r代表读,w代表写,a代表添加,b代表二进制位的。
    【考点4】文件函数
    判断文件结束feof函数,调用形式为:feof(FILE fp); //文件指针,如果文件结束,则函数返回1,否则返回0
    fseek用来设置文件的位置,接着的读或写操作将从此位置开始。函数的调用形式如下:
    fseek(文件指针,位移量,移动起始点);
    eg。FILE
    fp=fopen(“C:\xiaoyu.c”,”rb”);
    fseek(fp,12,SEEK_SET); //表示将文件fp的位置移动到文件起始位置后面的第12个字节的位置上
    或者 fseek(fp,12,0);

    fseek(fp,-12,SEEK_END; //表示将文件fp的位置移动到文件末尾位置前面的第12个字节的位置上
    或者 fseek(fp,12,2);

    如果是
    fseek(fp,12,SEEK_CUR); //表示将文件fp的位置从当前位置移动后面的第12个字节的位置上
    或者 fseek(fp,12,1);

    ftell用来获得文件当前的位置,函数给出当前位置相对于文件开头的字节数。函数调用形式如下:
    ftell(FILE *fp) //给出当前闻之相对于开头的字节数 ,出错时,返回-1L

    文件位置移到开头rewind函数功能等价于 fseek(fp,0,SEEK_SET)
    文件字符输入输出ch=fgetc(FILE *fp)函数用于从fp指定的文件中读入一个字符并把它作为函数值返回
    fputc(char ch,FILE *fp),将字符ch写到文件指针fp所指的文件中去,输出成功,则返回输出的字符,失败,则返回一个EOF值
    文件输入输出fscanf函数和fprintf函数,一般形式fscanf(文件指针,格式控制字符串,输入项表或输入项表)
    文件字符串输入输出fgets函数(fgets(str,n,fp),功能是从fp所指文件中读入n-1个字符放入str为起始地址的空间内)和fputs函数( fputs(str,fp) )
    读写二进制文件fread函数和fwrite函数。

    以上函数要求知道格式会用,清楚是用于二进制文件还是文本文件,要把教材文件这章仔细复习下,不要在考试的时候把这些文件函数搞混了。
    典型例题:
    给定程序中,函数fun的功能是将形参给定的字符串、整数、浮点数写到文本 文件中,再用字符方式从此文本文件中逐个读入并显示在终端屏幕上。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意:源程序存放在考生文件夹下的BLANK1.C中。
    不得增行或删行,也不得更改程序的结构!
    给定源程序:
    #include <stdio.h>
    void fun(char *s, int a, double f)
    {
    1 fp;
    char ch;
    fp = fopen(“file1.txt”, “w”);
    fprintf(fp, “%s %d %f\n”, s, a, f);
    fclose(fp);
    fp = fopen(“file1.txt”, “r”);
    printf("\nThe result :\n\n");
    ch = fgetc(fp);
    while (!feof(2)) {
    putchar(3); ch = fgetc(fp); }
    putchar(’\n’);
    fclose(fp);
    }
    main()
    { char a[10]=“Hello!”; int b=12345;
    double c= 98.76;
    fun(a,b,c);
    }

    第十二章 深入讨论
    【考点1】编译预处理
    凡以#开头的这一行,都是编译预处理命令行,编译预处理不加分号,不占运行时间。宏替换仅是简单的文本替换,如#define f(x) (x)(x)和#define f(x) xx替换f(2+2)时就有区别,前者展开为(2+2)(2+2),后者为2+22+2。
    如果源文件f2.c中有#include”f1.c”可以理解为把源文件f1.c原样包含到f2.c中,使f1.c和f2.c融合到一起成为一个C程序编译。所以一个C程序必有主函数,但一个C源文件未必有主函数。

    【考点2】标识符作用域
    局部变量是在函数内或复合语句内定义的变量,作用域为定义它的函数内。局部变量有三种类型:自动auto,寄存器register和静态static。
    自动变量随着函数的使用与否创建消失;寄存器变量分配在cpu中,没有内存地址;静态变量占用固定存储单元,在程序执行过程不释放,直到程序运行结束。
    全局变量是在函数外定义的变量,作用域从定义它的位置到整个源文件结束为止,生存期为整个程序运行期间。全局变量都是静态变量。
    eg
    .#include<stdio.h>
    int fun()
    {
    static int x = 1;
    x*=2;
    return x;
    }
    main()
    {
    int i,s=1;
    for(i=1;i<=3;i++)
    s*=fun();//i=1 S=2 i=2 S=8
    printf(“%d\n”,s);
    } 64
    【考点3】动态存储分配
    malloc(size)用来创建连续size个字节存储区,返回值类型为void *型。malloc函数常用于动态创建链表结点,如int *p; p=(int *)malloc(sizeof(int));。
    calloc(n,size)创建n个同一类型的存储空间,可以理解为n个malloc。
    free§释放动态分配的存储单元。

    第二部分 公共基础知识资料
    第一章 数据结构与算法
    【考点1】算法的基本概念
    算法:是指一组有穷的指令集,是解题方案的准确而完整的描述。算法不等于程序,也不等于计算方法。
    算法的基本特征:
    确定性,算法中每一步骤都必须有明确定义,不允许有多义性;
    有穷性,算法必须能在有限的时间内做完,即能在执行有限个步骤后终止;
    可行性,算法原则上能够精确地执行;
    拥有足够的情报。
    算法的组成要素:一个算法由数据对象的运算和操作以及其控制结构这两部分组成。
    算法的基本运算和操作:算术运算,逻辑运算,关系运算,数据传输。
    算法的基本控制结构:顺序,选择,循环。
    算法基本设计方法:列举法、归纳法、递推、递归、减半递推技术。
    【考点2】算法的复杂度
    算法效率的度量——算法的复杂度:时间复杂度和空间复杂度。
    算法时间复杂度:指执行算法所需要的计算工作量。通常,一个算法所用的时间包括编译时间和运行时间。
    算法空间复杂度:指执行这个算法所需要的内存空间。包括算法程序所占的空间,输入的初始数据所占的空间,算法执行过程中所需的额外空间。
    空间复杂度和时间复杂度并不相关。
    【考点3】数据结构的基本概念
    数据:数据是客观事物的符号表示,是能输入到计算机中并被计算程序识别和处理的符号的总称,如文档,声音,视频等。
    数据元素:数据元素是数据的基本单位。
    数据对象:数据对象是性质相同的数据元素的集合。
    数据结构:是指由某一数据对象中所有数据成员之间的关系组成的集合。
    【考点4】逻辑结构和存储结构
    数据结构可分为数据的逻辑结构和存储结构。
    数据的逻辑结构是对数据元素之间的逻辑关系的描述,与数据的存储无关,是面向问题的,是独立于计算机的。它包括数据对象和数据对象之间的关系。
    数据的存储结构也称为数据的物理结构,是数据在计算机中的存放的方式,是面向计算机的,它包括数据元素的存储方式和关系的存储方式。
    数据结构和逻辑结构的关系:一种数据的逻辑结构可以表示成多种存储结构即数据的逻辑结构和存储结构不一定一一对应。
    常见的存储结构有:顺序,链接,索引等。采用不同的存储结构其数据处理的效率是不同的。
    【考点5】线性结构和非线性结构
    线性结构的条件(一个非空数据结构):(1)有且只有一个根结点;(2)每一个结点最多有一个前件,也最多有一个后件。
    非线性结构:不满足线性结构条件的数据结构。
    栈、队列、双向链表是线性结构,树、二叉树为非线性结构。
    【考点6】线性表及其顺序存储结构
    线性表是由一组数据元素构成,数据元素的位置只取决于自己的序号,元素之间的相对位置是线性的。
    在复杂线性表中,由若干项数据元素组成的数据元素称为记录;由多个记录构成的线性表称为文件。
    非空线性表的结构特征:
    (1)有且只有一个根结点a1,它无前件;
    (2)有且只有一个终端结点an,它无后件;
    (3)除根结点与终端结点外,其他所有结点有且只有一个前件,也有且只有一个后件。
    结点个数n称为线性表的长度,当n=0时,称为空表。
    线性表的顺序存储结构具有以下两个基本特点:
    (1)线性表中所有元素所占的存储空间是连续的;
    (2)线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
    元素ai的存储地址为:ADR(ai)=ADR(a1)+(i-1)*k,ADR(a1)为第一个元素的地址,k代表每个元素占的字节数。
    顺序表的运算:查找、插入、删除。
    【考点7】线性链表
    线性链表是线性表的链式存储结构,数据结构中的每一个结点对应于一个存储单元,这种存储单元称为存储结点,简称结点。结点由两部分组成:(1) 用于存储数据元素值,称为数据域;(2) 用于存放指针,称为指针域,用于指向前一个或后一个结点。
    在链式存储结构中,存储数据结构的存储空间可以不连续,各数据结点的存储顺序与数据元素之间的逻辑关系可以不一致,而数据元素之间的逻辑关系是由指针域来确定的。
    链式存储方式既可用于表示线性结构,也可用于表示非线性结构。
    线性单链表中,HEAD称为头指针,HEAD=NULL(或0)称为空表。

    双向链表有两个指针:左指针(Llink)指向前件结点,右指针(Rlink)指向后件结点。

    循环链表:循环链表与单链表的不同的是它的最后一个结点的指针域存放的事指向第一个结点的指针而单链表存放的是空指针。

    线性链表的基本运算:查找、插入、删除。
    【考点8】栈
    1、栈的基本概念
    栈是一种特殊的线性表,只允许在表的一端进行插入和删除的线性表;插入,删除的一端为栈顶,另一端为栈底;当表中没有元素时为空栈。
    栈是一种后进先出(或先进后出Last In First Out)的线性表。栈具有记忆功能。栈的实例:火车调度,子弹夹。
    2、栈的存储结构
    顺序存储结构:用一组地址连续的存储单元即一维数组来存储;
    链式存储:用线性链表来存储;
    3、栈的基本运算
    (1) 入栈运算,在栈顶位置插入元素;
    (2) 退栈运算,删除元素(取出栈顶元素并赋给一个指定的变量);
    (3) 读栈顶元素,将栈顶元素赋给一个指定的变量,此时指针无变化。
    【考点9】队列
    1.队列的基本概念
    队列是一种特殊的线性表,只允许在表的一端插入,在另一端删除,允许插入的一端是队尾(rear),允许删除的一端为队头(front);当表中没有元素是空队列;队列是一种先进先出的线性表。(FIFO)
    2、队列的存储结构
    顺序存储:一维数组。
    链式存储:线性链表。队尾插;队头删
    3、队列的运算:
    (1) 入队运算:从队尾插入一个元素; (2) 退队运算:从队头删除一个元素。
    队列的顺序存储结构一般采用循环队列的形式。循环队列s=0表示队列为空;s=1且front=rear表示队满。
    计算循环队列的元素个数:“尾指针减头指针”,若为负数,再加其容量即可。
    【考点10】树的基本概念
    树是一种非线性结构,是n个结点的有限集。当n=0 时为空树,n>0时为非空树。结点的度:结点所拥有的子树的个数。
    叶子结点:度为0的结点。
    分支结点:除叶子结点以外的结点。
    结点的层次:根结点在第一层,同一层上左右结点的子结点在下一层。
    树的深度:所处层次最大的那个结点的层次。
    树的度:树中所有结点的度的最大值。
    【考点11】二叉树及其基本性质
    1、二叉树的概念
    二叉树是一种特殊的树形结构,每个结点最多只有两棵子树,且有左右之分不能互换,因此,二叉树有五种不同的形态,见教材12页。
    2、二叉树的性质
    性质1 在二叉树的第k层上,最多有2k-1(k≥1)个结点。
    性质2 深度为m的二叉树最多有2m-1个结点。
    性质3 在任意一棵二叉树中,度为0的结点(叶子结点)总是比度为2的结点多一个。
    性质4 具有n个结点的二叉树,其深度不小于[log2n]+1,其中[log2n]表示为log2n的整数部分。
    3、二叉树的存储结构:详见教材第13-14页。
    【考点12】满二叉树与完全二叉树
    满二叉树:除最后一层外,每一层上的所有结点都有两个子结点。在满二叉树中,每一层上的结点数都达到最大值,即在满二叉树的第k层上有2k-1个结点,且深度为m的满二叉树有2m-1个结点。
    完全二叉树是指这样的二叉树:除最后一层外,每一层上的结点数均达到最大值;在最后一层上只缺少右边的若干结点。
    满二叉树是完全二叉树,而完全二叉树一般不是满二叉树。
    【考点13】完全二叉树的性质
    性质1 具有n个结点的完全二叉树的深度为[log2n]+1。
    性质2 完全二叉树中度为1的结点数为0或1。
    【考点14】二叉树的遍历
    前序遍历:先访问根结点、然后遍历左子树,最后遍历右子树;并且,在遍历左、右子树时,仍然先访问根结点,然后遍历左子树,最后遍历右子树。
    前序遍历图5可得:ABCDFHEG。
    中序遍历:先遍历左子树、然后访问根结点,最后遍历右子树;并且,在遍历左、右子树时,仍然先遍历左子树,然后访问根结点,最后遍历右子树。
    中序遍历图5可得:BAFHDCGE。
    后序遍历:先遍历左子树、然后遍历右子树,最后访问根结点;并且,在遍历左、右子树时,仍然先遍历左子树,然后遍历右子树,最后访问根结点。
    后序遍历图5可得:BHFDGECA。

    【考点15】顺序查找
    顺序查找是从表的一端开始,依次扫描表中的各个元素,并与所要查找的数进行比较。
    在下列两种情况下也只能采用顺序查找:
    (1)如果线性表为无序表,则不管是顺序存储结构还是链式存储结构,只能用顺序查找。
    (2)即使是有序线性表,如果采用链式存储结构,也只能用顺序查找。
    【考点16】二分查找
    二分查找的条件:(1)用顺序存储结构 (2)线性表是有序表。
    查找的步骤:详见教材第16页。
    对于长度为n的有序线性表,在最坏情况下,二分法查找只需比较log2n次,而顺序查找需要比较n次。
    【考点17】排序
    1、交换排序
    (1)冒泡排序法,在最坏的情况下,冒泡排序需要比较次数为n(n-1)/2。
    (2)快速排序法 ,在最坏的情况下,快速排序需要比较次数为n(n-1)/2。
    2、插入类排序法:
    (1)简单插入排序法,最坏情况需要n(n-1)/2次比较;
    (2)希尔排序法,最坏情况需要O(n1.5)次比较。(大写O是算法复杂度的表示方法)
    3、选择类排序法:
    (1)简单选择排序法,最坏情况需要n(n-1)/2次比较;
    (2)堆排序法,最坏情况需要O(nlog2n)次比较。
    相比以上几种(除希尔排序法外),堆排序法的时间复杂度最小。
    第二章 程序设计基础
    【考点1】程序设计方法与风格
    形成良好的程序设计风格需注意:(详见教材第19页)。
    1、源程序文档化; 2、数据说明的方法; 3、语句的结构; 4、输入和输出。
    注释分序言性注释和功能性注释。
    语句结构清晰第一、效率第二。
    【考点2】结构化程序设计方法的四条原则
    1、自顶向下; 2、逐步求精; 3、模块化; 4、限制使用goto语句。
    【考点3】结构化程序的基本结构
    顺序结构:是最基本、最普通的结构形式,按照程序中的语句行的先后顺序逐条执行。
    选择结构:又称为分支结构,它包括简单选择和多分支选择结构。
    循环结构:根据给定的条件,判断是否要重复执行某一相同的或类似的程序段。循环结构对应两类循环语句:先判断后执行的循环体称为当型循环结构;先执行循环体后判断的称为直到型循环结构。
    【考点4】面向对象的程序设计及面向对象方法的优点
    面向对象的程序设计以对象为核心,强调对象的抽象性,封装性,继承性和多态性。
    面向对象方法的优点
    (1)人类习惯的思维方法一致; (2)稳定性好; (3)可重用性好;
    (4)易于开发大型软件产品; (5)可维护性好。
    【考点5】对象及其特点
    对象(object):面向对象方法中最基本的概念,可以用来表示客观世界中的任何实体,对象是实体的抽象。
    对象的基本特点:
    (1)标识惟一性; (2)分类性; (3)多态性; (4)封装性; (5)模块独立性好。
    【考点6】属性,类和实例
    属性:即对象所包含的信息,它在设计对象时确定,一般只能通过执行对象的操作来改变。
    类:是具有相似属性与操作的一组对象。类是关于对象性质的描述。类是对象的抽象,对象是其对应类的一个实例。
    【考点7】消息及其组成
    消息:是一个实例与另一个实例之间传递的信息。对象间的通信靠消息传递。它请求对象执行某一处理或回答某一要求的信息,它统一了数据流和控制流。
    消息的组成包括:
    (1)接收消息的对象的名称; (2)消息标识符,也称消息名; (3)零个或多个参数。
    【考点8】继承和多态
    继承:是使用已有的类定义作为基础建立新类的定义技术,广义指能够直接获得已有的性质和特征,而不必重复定义他们。
    继承具有传递性,一个类实际上继承了它上层的全部基类的特性。
    继承分单继承和多重继承。单继承指一个类只允许有一个父类,即类等级为树形结构;多重继承指一个类允许有多个父类。
    多态性:是指同样的消息被不同的对象接受时可导致完全不同的行动的现象
    第三章 软件工程基础
    【考点1】软件定义与软件特点
    软件指的是计算机系统中与硬件相互依存的另一部分,包括程序、数据和相关文档的完整集合。
    名称 描述
    程序 软件开发人员根据用户需求开发的、用程序设计语言描述的、适合计算机执行的指令序列
    数据 使程序能正常操纵信息的数据结构
    文档 与程序的开发、维护和使用有关的图文资料
    软件的特点:
    软件是一种逻辑实体,具有抽象性;
    软件的生产与硬件不同,它没有明显的制作过程;
    软件在运行、使用期间不存在磨损、老化问题;
    软件的开发、运行对计算机系统具有依赖性,受计算机系统的限制,这导致了软件移植的问题;
    软件复杂性高,成本昂贵;
    软件开发涉及诸多的社会因素。
    根据应用目标的不同,软件可分应用软件、系统软件和支撑软件(或工具软件)。
    名称 描述
    应用软件 为解决特定领域的应用而开发的软件,如办公自动化软件
    系统软件 计算机管理自身资源,提高计算机使用效率并为计算机用户提供各种服务的软件,如操作系统
    支撑软件(或工具软件) 支撑软件是介于两者之间,协助用户开发软件的工具性软件。
    【考点2】软件的生命周期
    软件生命周期是指软件产品从提出、实现、使用维护到停止使用退役的整个过程。可分为软件定义,软件开发及软件维护3个阶段。软件生命周期中,能够准确确定软件系统必须做什么和必须具备哪些功能的阶段是:需求分析。

    定义阶段 开发阶段 维护阶段
    【考点3】软件危机和软件工程的概念
    软件危机泛指在计算机软件的开发和维护过程中遇到的一系列严重的问题,集中表现在成本,质量。生产效率等几个方面。
    所谓软件工程是指采用工程的概念、原理、技术和方法指导软件的开发与维护。是建立并使用完善的工程化原则,以较经济的手段获得,能在实际机器上有效运行的可靠软件的一系列方法;软件工程的主要思想强调在软件开发过程中需要应用工程化原则。软件工程的核心思想是把软件当作一个工程产品来处理。
    软件工程包括3个要素:方法,工具和过程
    名称 描述
    方法 方法是完成软件工程项目的技术手段
    工具 工具支持软件的开发、管理、文档生成
    过程 过程支持软件开发的各个环节的控制、管理
    【考点4】软件工程过程
    软件工程过程是把软件转化为输出的一组彼此相关的资源活动,包含4种基本活动:
    (1)P(plan)——软件规格说明; (2)D(do)——软件开发;
    (3)C(check)——软件确认; (4)A(action)——软件演进。
    【考点5】软件开发技术和软件工程管理
    软件工程的理论和技术性研究的内容主要包括软件开发技术和软件工程管理。
    软件开发技术包括软件开发方法学、开发过程、开发工具和软件工程环境,其主体内容是软件开发方法学。
    软件开发方法包括分析方法,设计方法和程序设计方法。
    软件工程管理包括软件管理学,软件工程经济学,软件心理学等。
    软件管理学包括人员组织,进度安排,质量保证,配置管理,项目计划等。
    软件工程经济学是研究软件开发中成本的估算,成本效益的方法和技术。
    【考点6】软件工程的原则
    软件工程的原则:抽象,信息隐蔽,模块化,局部化,确定性,一致性,完备性,可验证性(详细见教材第28-29页)。
    【考点7】需求分析概述
    需求分析阶段的工作:需求获取,需求分析,编写需求规格说明书,需求评审。
    需求分析方法有:
    (1)结构化需求分析方法;
    ①面向数据结构的Jackson方法(ISD);
    ②面向数据流的结构化分析方法(SA);
    ③面向数据结构的结构化数据系统开发方法(DSSD);
    (2)面向对象的分析的方法(OOA)。
    从需求分析建立的模型的特性来分:静态分析和动态分析。
    【考点8】结构化方法和结构化分析方法
    1、结构化方法包括结构化分析方法,结构化设计方法,结构化编程方法。
    结构化方法中,软件功能分解属于总体设计阶段。
    2、结构化分析方法的概念
    结构化分析方法是面向数据流自顶而下逐步求精进行需求分析的方法。
    结构化分析方法在软件需求分析阶段的应用。
    3、结构化分析的常用工具
    数据流图(DFD-Data Flow Diagram):是结构化分析方法中用于系统逻辑模型的一种工具。它以图形的方式描绘在系统中流动和处理的过程。
    数据流图中四种基本的符号。
    箭头:表示数据流,数据流是数据在系统中传播的路径。
    圆或椭圆:表示加工,加工又称为数据处理,是对数据流进行某些操作或变换。
    双横:表示数据存储(数据源)。数据存储又称为文件,指暂时保存的数据,它可以是数据库文件或任何形式的数据组织。
    方框:源、潭。表示数据的源点或终点。它是软件系统外部环境中的实体,统称外部实体
    数据字典(DD):它是结构分析方法的核心,是用来描述系统中所用到的全部数据和文件的文档,作用是对DFD中出现的被命名的图形元素进行确切解释。
    数据字典由以下4类元素组成
    (1)数据流 (2)数据流分量 (3)数据存储 (4)处理
    判定树(决策树):是一种描述加工的图形工具,适合描述时候处理中具有多个判断,而且每个决策与若干条件有关。
    判定表:与判定树类似,也是一种描述加工的图形工具。如果一个加工逻辑有多个条件、多个操作,并且在不同的条件组合下执行不同的操作,那么可以使用判定表来描述。
    【考点9】软件需求规格说明书
    软件需求规格说明书(SRS,Software Requirement Specification)是需求分析阶段得出的最主要的文档。软件需求规格说明书的特点:有正确性、无歧义性、完整性、可验证性、一致性、可理解性、可修改性和可追踪性。其中最重要的是无歧义性。
    【考点10】软件设计的基本概念
    软件设计是确定系统的物理模型。
    软件设计是开发阶段最重要的步骤,是将需求准确地转化为完整的软件产品或系统的唯一途径。
    从技术观点上看,软件设计包括软件结构设计、数据设计、接口设计、过程设计。
    (1)结构设计定义软件系统各主要部件之间的关系;
    (2)数据设计将分析时创建的模型转化为数据结构的定义;
    (3)接口设计是描述软件内部、软件和协作系统之间以及软件与人之间如何通信;
    (4)过程设计则是把系统结构部件转换为软件的过程性描述。
    从工程管理角度来看,软件设计分两步完成:概要设计和详细设计。
    (1)概要设计将软件需求转化为软件体系结构、确定系统级接口、全局数据结构或数据库模式;
    (2)详细设计确立每个模块的实现算法和局部数据结构,用适当方法表示算法和数据结构的细节。
    【考点11】软件设计的基本原理
    1、软件设计中应该遵循的基本原理和与软件设计有关的概念:
    模块化:把程序划分成独立命名且可独立访问的模块,每个模块完成一个子功能。
    抽象化:抽出事物的本质特性而暂时不考虑它们的细节。
    信息隐藏和局部化:信息隐蔽是指在一个模块内包含的信息(过程或数据),对于不需要这些信息的其他模块来说是不能访问的,实现信息隐蔽依靠对象的封装。
    模块独立性:模块独立性是指每个模块只完成系统要求的独立的子功能,并且与其他模块的联系最少且接口简单。模块的独立程度是评价设计好坏的重要度量标准。
    【考点12】耦合性和内聚性
    衡量软件的模块独立性是用耦合性和内聚性两个定性的度量标准。
    耦合性:是对一个软件结构内不同模块之间互联程度的度量。耦合性的强弱取决于模块间接口的复杂程度。
    内聚性:是一个模块内部各个元素间彼此结合的紧密程度的度量。
    一个模块的内聚性越强则该模块的模块独立性越强。一个模块与其他模块的耦合性越强则该模块的模块独立性越弱。
    在结构程序设计中,模块划分的原则是模块内具有高内聚度,模块间具有低耦合度。
    耦合和内聚的种类(详见教材第35页)。
    耦合度由低到高:非直接耦合,数据耦合,标记耦合,控制耦合,外部耦合,公共耦合,内容耦合。
    内聚性由强到弱:功能内聚,顺序内聚,通信内聚,过程内聚,时间内聚,逻辑内聚,偶然内聚。
    【考点13】结构化设计方法
    结构化分析方法是面向数据流自顶而下,逐步求精进行需求分析的方法,基本思想将软件设计成由相对独立,单一功能的模块组成的结构,与结构分析方法衔接使用,以数据流图为基础得到软件的模块结构,适用于变换型结构和事物型结构的目标系统。
    1、概要设计的任务:(1)划分出组成系统的物理元素 (2)设计软件的结构
    2、概要设计的工具:
    结构图(SC-Structure Chart)也称程序结构图,在结构图中,模块用一个矩形表示,箭头表示模块间的调用关系。可以用带注释的箭头表示模块调用过程中来回传递的信息。还可用带实心圆的箭头表示传递的是控制信息,空心圆箭心表示传递的是数据。
    结构图的基本形式:基本形式、顺序形式、重复形式、选择形式。
    结构图有四种模块类型:传入模块、传出模块、变换模块和协调模块。
    程序结构图中的专业术语:
    名称 描述
    深度 表示控制的层数
    上级模块,从属模块 上,下两层模块a和b,且有a调用b,则a是上级模块,b是从属模块
    宽度 整体控制跨度(最大模块的层)的表示
    扇入 调用该模块的模块个数
    扇出 一个模块直接调用的其他模块数
    原子模块 树中位于叶子节点的模块
    3、面向数据流的设计方法
    任何软件系统都可以用数据流图表示,典型的数据流类型有两种:变换型和事务型。
    变换型系统结构图由输入、中心变换、输出三部分组成。
    4、设计的准则
    (1)提高模块独立性。
    (2)模块规模适中。
    (3)深度,宽度,扇出和扇入适当。如果深度过大,则说明有的控制模块可能简单了,如果宽度过大,则说明系统的控制过于集中,扇出过大说明模块过分复杂,需要控制和协调过多的下级模块,应适当加中间层次,扇出过小可以把模块进一步分解成若干小模块,或合并到上级模块中,扇入越大则共享该模块的上级数目越多。好的软件设计结构通常顶层高扇出,中间扇出较少,底层高扇入。
    (4)使模块的作用域在该模块的控制域内。
    (5)减少模块的接口和界面的复杂性。
    (6)设计成单入口,单出口的模块。
    (7)设计功能可预测的模块。
    详细设计常用的设计工具(工程设计工具):图形工具,表格工具和语言工具。
    图形工具:
    程序流程图:箭头表示控制流,方框表示加工步骤,菱形表示逻辑条件。
    N-S图:有五种基本图形。
    PAD图:问题分析图,有五种基本图型。
    表格工具:判定表。
    语言工具:PDL——过程设计语言(结构化的英语和伪码)。
    【考点14】软件测试的目标和准则
    软件测试的目标:发现程序中的错误。
    软件测试的准则:
    (1)所有测试都是应追溯到需求。
    (2)严格执行测试计划,排除测试的随意性。
    (3)充分注意测试中的群集表现。程序中存在错误的概率与该程序中已发现的错误数成正比。
    (4)程序员应避免检查自己的程序。
    (5)穷举测试不可能。穷举测试是把程序所有可能的执行路径都进行检查,即使小规模的程序的执行路径数也相当大,不可能穷尽,说明测试只能证明程序有错,不能证明程序中无错。
    (6)妥善保存测试计划,测试用例出错统计和最终分析报告。
    【考点15】软件测试方法
    从是否需要执行被测软件的角度分为静态测试和动态测试;按功能分为白盒测试和黑盒测试
    1、静态测试和动态测试
    静态测试包括代码检查、静态结构分析、代码质量度量。不实际运行软件,主要通过人工进行。
    动态测试是通过运行软件来检验软件中的动态行为和运行结果的正确性。动态测试的关键是使用设计高效、合理的测试用例。测试用例就是为测试设计的数据,由测试输入数据(输入值集)和预期的输出结果(输出值集)两部份组成。测试用例的设计方法一般分为两类:黑盒测试方法和白盒测试方法。
    2、白盒测试和黑盒测试
    (1)白盒测试
    白盒测试也称为结构测试或逻辑测试,是把程序看成装在一只透明的白盒子里,测试者完全了解程序的结构和处理过程。它根据程序的内部逻辑来设计测试用例,检查程序中的逻辑通路是否都按预定的要求正确地工作。
    白盒测试的基本原则:
    (1)保证所测模块中每一独立路径至少执行一次。
    (2)保证所测模块所有判断的每一分支至少执行一次。
    (3)保证所测模块每一循环都在边界条件和一般条件下至少各执行一次。
    (4)验证所有内部数据结构的有效性。
    (5)按照白盒测试的基本原则,“白盒”法是穷举路径测试。
    白盒测试的方法:逻辑覆盖,基本路经测试。
    (2)黑盒测试
    黑盒测试也称功能测试或数据驱动测试,是把程序看成一只黑盒子,测试者完全不了解,或不考虑程序的结构和处理过程。它根据规格说明书的功能来设计测试用例,检查程序的功能是否符合规格说明的要求。
    黑盒测试的方法:等价划分法,边界值分析法,错误推测法。
    【考点16】软件测试的实施
    软件测试过程分4个步骤,即单元测试、集成测试、验收测试和系统测试。
    单元测试是对软件设计的最小单位——模块进行正确性检验的测试,单元测试的根据是源程序和详细设计说明书,单元测试的技术可以采用静态分析和动态测试。
    单元测试期间对模块进行的测试:模块接口,局部数据结构,重要的执行通路,出错处理通路,边界条件。
    驱动模块相当于被测模块的主程序,它接收测试数据,并传给所测模块,输出实际测试结果
    桩模块通常用于代替被测模块调用的其他模块,其作用仅做少量的数据操作,是一个模拟子程序。
    集成测试是测试和组装软件的系统化技术,主要目的是发现与接口有关的错误,集成测试的依据是概要设计说明书。
    集成测试的方法:非增量方式组装和增量方法组装。
    增量方式包括自顶而下的增量方式,自底而上的增量方式和混合增量方式。
    确认测试的任务是验证软件的功能和性能,确认测试的实施首先运用黑盒测试方法,对软件进行有效性测试,即验证被测软件是否满足需求规格说明确认的标准。
    检查软件产品是否符合需求定义的过程是:确认测试。
    系统测试是通过测试确认的软件,作为整个基于计算机系统的一个元素,与计算机硬件、外设、支撑软件、数据和人员等其他系统元素组合在一起,在实际运行(使用)环境下对计算机系统进行一系列的集成测试和确认测试。
    系统测试的具体实施一般包括:功能测试、性能测试、操作测试、配置测试、外部接口测试、安全性测试等。
    【考点17】程序调试
    在对程序进行了成功的测试之后将进入程序调试(通常称Debug,即排错)。
    程序的调试任务是诊断和改正程序中的错误。
    程序调试和软件测试的区别:
    (1)软件测试是尽可能多地发现软件中的错误,而程序调试先要发现软件的错误,然后借助于一定的调试工具去执行找出软件错误的具体位置。
    (2)软件测试贯穿整个软件生命期,调试主要在开发阶段。
    程序调试的基本步骤:
    (1)错误定位。从错误的外部表现形式入手,研究有关部分的程序,确定程序中出错位置,找出错误的内在原因;
    (2)修改设计和代码,以排除错误;
    (3)进行回归测试,防止引进新的错误。
    软件调试可分为静态调试和动态调试。静态调试主要是指通过人的思维来分析源程序代码和排错,是主要的设计手段,而动态调试是辅助静态调试的。
    主要的调试方法有:
    (1)强行排错法; (2)回溯法; (3)原因排除法,包括演绎法,归纳法和二分法。
    第四章 数据库设计基础
    【考点1】数据库的基本概念
    数据(Data)是数据库存储的基本对象,是描述事物的符号记录。
    数据库(DB)是长期储存在计算机内、有组织的、可共享的大量数据的集合,它具有统一的结构形式并存放于统一的存储介质内,是多种应用数据的集成,并可被各个应用程序所共享,所以数据库技术的根本目标是解决数据共享问题。
    数据库管理系统(DBMS)是数据库的管理机构,负责数据库中的数据组织、数据操纵、数据维护、控制及保护和数据服务等。数据库管理系统是数据库系统的核心。数据库系统包含数据库和数据库管理系统。
    数据库管理系统的功能:
    (1)数据模式定义:即为数据库构建其数据框架;
    (2)数据存取的物理构建:为数据模式的物理存取与构建提供有效的存取方法与手段;
    (3)数据操纵:为用户使用数据库的数据提供方便,如查询、插入、修改、删除等以及简单的算术运算及统计;
    (4)数据的完整性、安全性定义与检查;
    (5)数据库的并发控制与故障恢复;
    (6)数据的服务:如拷贝、转存、重组、性能监测、分析等。
    为完成数据库管理系统的功能,数据库管理系统提供相应的数据语言:
    数据定义语言(DDL):负责数据模式定义和数据物理存取构建。
    数据操纵语言(DML):负责数据的操纵。
    数据控制语言(DCL):负责数据完整性,安全性的定义与检查以及并发控制,故障恢复等功能。
    数据语言按使用方式具有两个结构形式:交互式命令语言(自含型和自主型语言)和宿主型语言。
    数据库管理员(DBA)的工作:数据库设计,数据库维护,改善系统性能,提高系统效率。
    数据库系统(DBS)是指在计算机系统中引入数据库后的系统,一般由数据库、数据库管理系统、应用系统、数据库管理员和用户构成。
    数据库应用系统(DBAS)是数据库系统再加上应用软件及应用界面这三者所组成,具体包括:数据库、数据库管理系统、数据库管理员、硬件平台、软件平台、应用软件、应用界面。
    【考点2】数据管理的发展和基本特点
    数据管理技术的发展经历了三个阶段:人工管理阶段、文件系统阶段和数据库系统阶段,数据独立性最高的阶段是数据库系统阶段。
    人工管理阶段特点:(1)计算机系统不提供对用户数据的管理功能(2)数据不能共享(3)不单独保存数据。
    文件系统阶段的缺陷:(1)数据冗余(2)不一致性(3)数据联系弱。
    数据库系统的发展阶段:第一代的网状、层次数据库系统;第二代的关系数据库系统;第三代的以面向对象模型为主要特征的数据库系统。
    数据库系统的基本特点:
    (1)数据的高集成性 (2)数据的高共享性和低冗余性 (3)数据高独立性 (4)数据统一管理与控制。
    数据独立性是数据与程序间的互不依赖性,即数据库中的数据独立于应用程序而不依赖于应用程序。
    数据的独立性一般分为物理独立性与逻辑独立性两种。
    (1)物理独立性:当数据的物理结构(包括存储结构、存取方式等)改变时,其逻辑结构,应用程序都不用改变。
    (2)逻辑独立性:数据的逻辑结构改变了,如修改数据模式、增加新的数据类型、改变数据间联系等,用户的应用程序可以不变。
    【考点3】数据系统的内部结构体系
    1、数据统系统的三级模式:
    (1)概念模式,也称逻辑模式,是对数据库系统中全局数据逻辑结构的描述,是全体用户公共数据视图。一个数据库只有一个概念模式。
    (2)外模式,外模式也称子模式,它是数据库用户能够看见和使用的局部数据的逻辑结构和特征的描述,一个概念模式可以有若干个外模式。
    (3)内模式,内模式又称物理模式,它给出了数据库物理存储结构与物理存取方法。一个数据库只有一个内模式。
    内模式处于最底层,它反映了数据在计算机物理结构中的实际存储形式,概念模式处于中间层,它反映了设计者的数据全局逻辑要求,而外模式处于最外层,它反映了用户对数据的要求。
    2、数据库系统的两级映射 (详见教材第55页)
    两级映射保证了数据库系统中数据的独立性。
    (1)概念模式到内模式的映射。该映射给出了概念模式中数据的全局逻辑结构到数据的物理存储结构间的对应关系;
    (2)外模式到概念模式的映射。概念模式是一个全局模式而外模式是用户的局部模式。一个概念模式中可以定义多个外模式,而每个外模式是概念模式的一个基本视图。
    【考点4】数据模型的基本概念
    数据模型按不同的应用层次分为:
    概念数据模型:简称概念模型,是一种面向客观世界,面向用户的模型,不涉及具体的硬件环境和平台也与具体的软件环境无关的模式,它是整个数据模型的基础。
    逻辑数据模型:又称数据模型,它是一种面向数据库的模型。分为层次模型,网状模型,关系模型和面向对象模型,其中层次模型和网状模型统称为非关系模型。层次模型用树型结构表示实体之间联系的模型。
    物理数据模型:又称物理模型,它是一种面向计算机物理表示的模型。
    【考点5】E—R模型
    1、E-R模型的基本概念
    (1)实体:现实世界中的事物可以抽象成为实体,实体是概念世界中的基本单位,它们是客观存在的且又能相互区别的事物。
    (2)属性:现实世界中事物均有一些特性,这些特性可以用属性来表示。
    (3)码:唯一标识实体的属性集称为码。
    (4)域:属性的取值范围称为该属性的域。
    (5)联系:在现实世界中事物间的关联称为联系。
    两个实体集间的联系实际上是实体集间的函数关系,这种函数关系可以有下面几种:一对一的联系、一对多或多对一联系、多对多。
    2、E-R模型的的图示法
    E-R模型用E-R图来表示,E-R图包含了表示实体集、属性和联系的方法。
    (1)实体的表示:用矩形表示实体集,在矩形内写上该实体集的名字。
    (2)属性的表示:用椭圆形表示属性,在椭圆形内写上该属性的名称。
    (3)联系的表示:用菱形表示联系,菱形内写上联系名。
    【考点6】层次模型和网状模型
    层次模型是有根的定向有序树,是数据库系统中最早出现的数据模型。网状模型对应的是有向图。
    层次模型和网状模型各自应满足的条件
    模型名称 满足的条件
    层次模型 (1)有且只有一个结点没有双亲结点,这个结点称为根结点
    (2)根以外的其他结点有且只有一个双亲结点
    网状模型 (1)允许一个以上的结点无双亲
    (2)一个结点可以有多于一个的双亲
    【考点7】关系模型及相关概念
    关系模式采用二维表来表示,由关系数据结构,关系操纵和关系完整性约束3部分组成,在关系数据库中,用来表示实体间联系的是关系。
    关系:一个关系对应一张二维表。一个关系就是一个二维表,但是一个二维表不一定是一个关系。
    元组:表中的一行即为一个元组。
    属性:表中的一列即为一个属性,给每一个属性起一个名称即属性名。
    分量:元组中的一个属性值,是不可分割的基本数据项。
    域:属性的取值范围。
    在二维表中惟一标识元组的最小属性值称为该表的键或码。二维表中可能有若干个健,它们称为表的候选码或候选健。从二维表的所有候选键选取一个作为用户使用的键称为主键或主码。表A中的某属性集是某表B的键,则称该属性值为A的外键或外码。
    关系操纵:数据查询、数据的删除、数据插入、数据修改。
    关系模型允许定义三类数据约束,它们是实体完整性约束、参照完整性约束以及用户定义的完整性约束。其中实体完整性约束、参照完整性约束必须满足的完整性约束条件。参照完整性约束不允许关系应用不存在的元组。实体完整性约束要求关系的主键中属性值不能为空,这是数据库完整性的最基本要求。
    【考点8】关系代数
    关系代数是一种抽象的查询语言,关系代数的运算对象是关系,运算结果也是关系。运算对象,运算符和运算结果是运算的三大要素。集合运算符,专门的运算符,算术比较符和逻辑运算符。
    关系模型的基本运算:(1)插入 (2)删除 (3)修改 (4)查询(包括投影、选择、笛卡尔积运算)还有扩充运算交、除、连接及自然连接运算。
    关系代数的5个基本操作中并,差,交,笛卡尔积是二目运算。
    设关系R和S具有相同的关系模式
    1、并:R和S的并是由属于R或属于S的所有元组构成的集合。
    2、差:R和S的差是由属于R但是不属于S的元组构成的集合
    3、笛卡尔积:设R和S的元数分别为r和s,R和S的笛卡尔积是一个(r+s)元的元组集合,每个元组的前r个分量来自R的一个元组,后s个分量来自S的一个元组。运算后得到的新表的元组数是R*S,属性是r+s。
    4、交:属于R又属于S的元组构成的集合。
    5、投影:一元运算,对一个关系进行垂直切割,消去某些列,并重新按排列的顺序。
    6、选择:一元运算,根据某些条件对关系进行水平分割。即选择符合条件的元组。
    7、除:给定关系R(X,Y)和S(Y,Z),其中X,Y,Z是属性组,R中的Y和S中Y可以有不同的属性名,但必须出自相同的域集。
    8、连接:也称θ连接运算,是一种二元运算,它的操作是从两个关系的笛卡尔积中选取属性间满足一定条件的元组,以合并成一个大关系。连接运算包括等值连接和不等值连接。连接运算后得到的新表的属性是运算前表中属性相加。即多于原来关系中属性的个数。
    9、自然连接:自然连接满足的条件是(1)两关系间有公共域(2)通过公共域的相等值进行连接。
    【考点9】数据库设计和管理
    数据库设计中有两种方法,面向数据的方法和面向过程的方法。
    面向数据的方法是以信息需求为主,兼顾处理需求;面向过程的方法是以处理需求为主,兼顾信息需求。由于数据在系统中稳定性高,数据已成为系统的核心,因此面向数据的设计方法已成为主流。
    数据库设计目前一般采用生命周期法,即将整个数据库应用系统的开发分解成目标独立的若干阶段。它们是:需求分析阶段、概念设计阶段、逻辑设计阶段、物理设计阶段。
    一个低一级范式的关系模式,通过模式分解可以转化为若干个高一级范式的关系模式的集合,这种过程就叫规范化。
    概念结构设计是将需求分析阶段得到的用户需求抽象为信息结构即概念模型的过程,它是整个数据库设计的关键。
    逻辑结构设计的任务是将E—R图转换成关系数据模型的过程。
    数据库的物理结构是指数据库在物理设备上的存储结构和存取方法。它依赖于给定的计算机系统。
    常用的存取方法:索引方法,聚簇方法和HASH方法。
    数据库管理的内容:
    (1)数据库的建立,它是数据库管理的核心,包括数据模式的建立和数据加载。
    (2)数据库的重组。
    (3)数据库安全性控制。
    (4)数据库的完整性控制,数据库的完整性是指数据的正确性和相容性。
    (5)数据库的故障恢复。
    (6)数据库监
    输入输出
    有以下程序段
    int j;
    float y;
    char name[50];
    scanf(“%2d%f%s”,&j,&y,name);
    若从键盘上输入55 566 7777qbc后,y的值为(566.0)

    循环
    #include<stdio.h>
    main()
    {
    int x =8;
    for(;x>0;x–)
    {
    if(x%3) 8 5 4 2
    {
    printf(“%d”,x–);
    continue;
    }
    printf(“%d”,–x);
    }
    }
    函数
    void f(int v,int w)
    {
    int t;
    t=v;
    v=w;
    w=t;
    }
    main()
    {
    int c=1,y=3,z=2;
    if(x>y)
    f(x,y);
    else if(y>z)
    f(y,z);
    else
    f(x,z);
    printf(“%d,%d,%d\n”,x,y,z);
    }

    字符串的操作
    #include<stdio.h>
    main()
    {
    char s[]=”012xy\08s34f4w2”;
    int i,n=0;
    for(i=0;s[i]!=0;i++)
    if(s[i]>=’0’ &&s[i]<=’9’) n++;
    printf(“%d\n”,n);
    }
    (3)

    指针基本操作
    #include<stdio.h>
    #include<stdlib.h>
    main()
    {
    int *a,*b,*c;
    a = b = c=(int *)malloc(sizeof(int));
    *a = 1;*b=2,*c = 3;
    a=b;
    printf(“%d,%d,%d\n”,*a,*b,*c);
    }
    (3,3,3)
    b = *p++;//指针变量p会先与++结合,相当于先取指针变量p所指向的存储单元中的值赋给变量b,然后使指针变量p自增1
    指针数组:一般定义形式如下: 类型名 指针数组名[常量表达式]
    如,int p[3]; //因为[]的优先级高于号,因此,p首先与【】结合,构成p【3】,说明了p是一个数组名,在它前面的
    号说明数组p中的每个元素只能存放指针

                                                        a[0][0]
      P[0]                                              
                                                        a[0][1]
      P[1]                                                 
                                                        a[1][0]
      P[2]
    

    数组及指针
    #include<stdio.h>
    main()
    {
    int x[3][2]={0},i;
    for(i=0;i<3;i++)
    scanf(“%d”,x[i]);
    printf(“%3d%3d%3d\n”,x[0][0],x[0][1],x[1][0]);
    } 若运行时输入:2 4 6<回车>,则输出结果是(2 0 4)

    结构体知识点补充:
    struct student
    {
    char name[10];
    char sex;
    int age;
    float score;
    };
    Struct student s1,*ps,stu[3];
    eg.
    struct S
    {
    int a;
    int b;
    }data[2]={10,100,20,200};

    main()
    {
    sturct s p =data[1];
    printf(“%d\n”,(++p.a));
    }
    (21)

    链表:
    结构体中含有指向本结构体类型的指针成员,例如下面
    #include “stdio.h”
    #include"stdlib.h"
    struct link
    {
    char data;
    struct link *next;
    };
    typedef struct link LINK;
    LINK *create_list()
    {
    char ch;
    LINK *h,s,r;
    h = (LINK
    )malloc(sizeof(LINK));
    r = h;
    printf(“请输入一些字母(空格也被认为是字母,回车结束)”);
    ch = getchar();
    while(ch !=’\n’)
    {
    s = (LINK
    )malloc(sizeof(LINK));
    s->data=ch;
    printf("%c",ch);
    r->next=s;
    r = s;
    ch=getchar();
    }
    r->next = NULL;
    return h;
    }
    void print_list(LINK *h)
    {
    LINK *p;
    p = h->next;
    if(p==NULL)
    printf(“The List is NULL\n”);
    else
    while(p!= NULL)
    {
    printf("%c",p->data);
    p=p->next;
    }
    printf("\n\n");
    }

    int add_node_at_front(LINK *head,char newData)
    {
    LINK *p;
    p =(LINK *)malloc(sizeof(LINK));
    p->data = newData;
    if(headNULL)
    {
    head = p;
    p->next = NULL;
    }
    else
    {
    p->next = head;
    head ->next = p;
    }
    return 1;
    }
    void del_node(LINK *head,char dataToDel)
    {
    LINK *p = head,*pPre=head;
    if(p
    NULL)
    return;
    printf(“come to del_node,head->data is %c,deldata is %c\n”,head->data,dataToDel);
    while(p!=NULL)
    {
    if(p->data == dataToDel)
    {

    if(p==head)
    {
    printf(“come to del_node 1\n”);
    free§;
    head = pPre=p=NULL;
    if(head == NULL)
    printf("head is null ");
    else
    printf(“head is %d”,head);
    }
    else
    {
    pPre->next = p->next;
    free§;
    p=NULL;
    }
    break;
    }
    pPre=p;
    p = p->next;
    }
    }
    LINK *find_node(LINK *head,char dataToFind)
    {
    LINK *p = head;
    while(p!= NULL)
    {
    if(p->data == dataToFind)
    {
    return p;
    }
    p = p->next;
    }
    return NULL;
    }

    int modify_node(LINK *head,char oldData,char newData)
    {
    LINK *p = head;
    p = find_node(head,oldData);
    if(p != NULL)
    {
    p->data = newData;
    return 1;
    }
    return 0;
    }
    main()
    {
    char c,cNew;
    LINK *head,*p;
    head = create_list();
    printf("%d",head);
    print_list(head);
    c = getchar();
    del_node(head,c);

    print_list(head);	
    

    }
    冒泡排序
    冒泡排序每一趟排序把最大的放在最右边。
    比如:
    87 12 56 45 78
    87和12交换:12 87 56 45 78
    87和56交换: 56 87 45 78
    87和45交换: 45 87 78
    87和78交换: 78 87
    到此第一趟排序结束,接下来的每一趟排序都是这样。

    #include<stdio.h>
    void Print(int *num, int n)
    {
    int i;
    for(i = 0; i < n; i++)
    printf("%d “, num[i]);
    puts(”\n");
    return;
    }
    void Bubble_Sort(int *num, int n)
    {
    int i, j;
    for(i = 0; i < n; i++)
    {
    for(j = 0; i + j < n - 1; j++)
    {
    if(num[j] > num[j + 1])
    {
    int temp = num[j];
    num[j] = num[j + 1];
    num[j + 1] = temp;
    }
    Print(num, n);
    }
    }
    return;
    }
    int main()
    {
    int num[8] = {87, 12, 56, 45, 78};
    Bubble_Sort(num, 5);
    return 0;
    }

    快速排序:
    1.一、假设我们给一个int数组进行排序,数组中数字初始序列为int a[9]={3,6,5,9,7,1,8,2,4}

    2.2
    二、分析快速排序的原理前,我们先声明一些东西,首先设置一个临时变量用来存放随机取出数组中的一个数,一般我们取数组的第一个元素也就是说temp=a[0],同时设置两个游标分别指向数组第一个元素和最后一个元素。

    3.3
    三、算法的基本运算步骤为:1、依次比较数组的后游标所指与temp的大小,如果temp<a[j],则j–,直到遇到第一个temp>a[j],则停止移动,将a[j]赋值给a[i]
    4.4
    四、算法的基本运算步骤为:2、依次比较数组的前游标所指与temp的大小,如果temp>a[i],则i++,直到遇到第一个temp<a[i],则停止移动,将a[i]赋值给a[j]
    5.5
    五、算法运算步骤为:3、判断i是否等于j,如果不相等则循环1、2步,直到i等于j,则完成一次快速排序。

    展开全文
  • Python知识点(史上最全)

    万次阅读 多人点赞 2021-07-28 22:40:37
    Python期末考试知识点(史上最全) python简介 Python是一种解释型语言 Python使用缩进对齐组织代码执行,所以没有缩进的代码,都会在载入时自动执行 数据类型:整形 int 无限大 浮点型 float 小数 复数 ...

    Python期末考试知识点(史上最全)

    请添加图片描述
    请添加图片描述

    请添加图片描述

    请添加图片描述

    请添加图片描述

    请添加图片描述
    请添加图片描述

    请添加图片描述

    python简介

    Python是一种解释型语言
    Python使用缩进对齐组织代码执行,所以没有缩进的代码,都会在载入时自动执行
    数据类型:整形          int              无限大 
                      浮点型      float            小数
                      复数         complex       由实数和虚数组成
    
    Python中有6个标准的数据类型:
            Number(数字)
            String(字符串)
            List(列表)
            Tuple(元组)
            Sets(集合)
            Dictionart(字典)
    其中不可变得数据:
                   Number(数字)            String(字符串)            Tuple(元组)            Sets(集合)
    可变得:
                   List(列表)         Dictionart(字典)    
    我们可以用type或者isinstance来判断类型
    

    请添加图片描述

    type()不会认为子类是一种父类类型。
    isinstance()会认为子类是一种父类类型

    python中定义变量,不需要写变量类型,但是必须初始化。会根据我们写的数据类型,自动匹配
    变量命名规则:由字母,数字,下划线组成,第一个必须字母或者下划线,对大小写敏感,不能是关键字
    
    输入与输出
        在我们需要输入中文的时候,需要包含头文件  # -*- coding: UTF-8 -*- 或者 #coding=utf-8
        输入    a=input("请输入一个数字")          返回值为str类型
        输出    print('hello world')                        当然这里也可以严格按照格式控制符去输出变量值
            例如:print("now a=%d,b=%d"%(a,b))        双引号后面没有逗号
         print默认换行,我们可以print( end=''),修改默认参数让他不换行,
                                    也可以在print()后面加逗号  print(xxx) ,   这样也可以不换行    测试发现:只适合在2.7版本
    
    1. 基础语法
      运算符:
      算术运算符: 多了一个**,代表 幂方 5**5 就是5的5次方 还多了一个 // 整数除法
      逻辑运算符: and,or,not 与,或,非
      赋值运算符: 没有++,–
      身份运算符: is is not

    成员关系运算符: in not in
    总结:多出来了** 和 // //就是整除的意思 比如 5//3结果为 1 但是5/3结果为小数 1.6666666667

    运算符优先级(下面由高到低):幂运算符最高
    幂运算符                **
    正负号                    + -
    算术运算符            *,/,//,+,-
    比较运算符            <,<=,>,>=,==,!=
    逻辑运算符            not,and,or    (not>and>or)
    

    选择结构
    if-else
    if-elif-else(这里可以不写else)

         逻辑结果
            python里面只要是"空”的东西都是false    ""(中间有空格就为真,这里什么都不写,为假)    空元组,空列表,空字典    0 都为false
    

    字符串
    请添加图片描述

    Pis:在字符串前面添加一个 r,表示原始字符串,不会发生转义
    列表
    list是处理一组有序项目的数据结构,用方括号定义
    列表的操作:
    一,通过下标去访问列表中的值 (可以用切片的方式去访问)

         输出结果:这里就用了切片的方式去访问1到5
          
    重点:这里切片的使用方法要注意,我们写的1:5实际访问的是下标为1,2,3,4.没有5!
    

    请添加图片描述

    二,更新列表(列表是可以修改的)
    通过下标去直接修改他的值

    三,删除列表元素(del + 列表项) 删除项remove()后面说
    请添加图片描述

    四,列表的脚本操作符

    请添加图片描述

    五,对于列表截取,拼接
    请添加图片描述

    六,list自带函数 (其中有元组转列表)

    方法 功能
    max(list) 返回列表元素最大值
    min(list) 返回列表元素最小值
    list(seq) 元组转列表
    list.append(obj) 在列表末尾添加新对象
    list.count(obj) 统计某个元素在列表出现的次数
    list.extend(seq) 在末尾添加新列表,扩展列表
    list.index(obj) 在列表中找出某个值第一个匹配性的索引位置
    list.insert(index,obj) 将对象插入列表,其中的index,为插入的位置,原来该位置后面的元素包含该位置元素,都统一后移
    list.pop(obj=list[-1])
    有默认参数,即最后一项 删除指定位置元素并返回,他和del的区别在于del是一个关键字。而pop是内建函数,我们无法用变量去接收del删除的项 (参数可以不写,默认删除最后一项)
    list.remove(obj) 移出列表中某个值第一次匹配的项
    list.reverse() 反向列表中的元素(收尾互换),不代表倒序排列!
    list.sort() 对列表进行排序
    list.copy() 复制列表
    list.clear() 清空列表

    Set集合
    集合是一个无序不重复元素的序列
    基本功能就是进行成员关系测试,和删除重复元素 (所谓成员关系测试就是查看他们是否重复,两个集合的交集…)
    可以使用 { } 或者set()函数来创建集合 但是创建一个空集合必须适用set()
    请添加图片描述

    编程语言的进化:机器语言、汇编语言、高级语言

    机器语言:由于计算机内部只能接受二进制代码,因此,用二进制代码0或1描述的指令称为机器指令,全部机器指令的集合构成计算机的机器语言。

    汇编语言:实质和机器语言是相同的,都是直接对硬件操作,只不过指令采用英文缩写的标识符,更容易识别和记忆。

    高级语言:高级语言对开发人员更加友好,开发效率大大提高

    高级语言所编制的程序不能直接被计算机识别,必须经过转换才能被执行。

    高级语言按转换方式可分为:编译型、解释型

    编译型:指在应用源程序执行之前,将程序源代码转换成目标代码,因此其目标代码可以脱离其语言环境独立执行。

    编译后程序运行时不需要重新翻译,直接使用翻译的结果就行。程序执行效率高,依懒性编译器,跨平台性差。如C、C++、GO、Delphi等

    解释型:应用程序源代码一边由相应语言的解释器翻译成目标代码,一边执行,因此效率比较低,不能生成可独立执行的可执行文件,应用程序不能脱离其解释器。如Python、Java、PHP、Ruby等。跨平台性好、开发效率不高。

    编译型语言执行速度快,不依赖语言环境运行,跨平台差

    解释型跨平台好,一份代码,到处运行。缺点是执行速度慢,依赖解释器运行。

    Python创始人:Guido van Rossum(龟叔)

    Python诞生在1989年

    2008年12月出现Python3.0

    2010年出现一个过渡版本Python2.7(最多只支持到2020年,之后不支持2.0版本)

    Python解释器是用C语言写的

    Python解释器种类有:CPython、IPython、PyPy、Jython、IronPython

    测试安装是否成功:

    windows–>运行–>输入cmd,回车,弹出cmd程序,输入Python,如果进入交互环境,代表安装成功。

    print(‘hello world!’)

    保存为helloworld.py,注意.py后缀名的作用:命名约束规范,方便程序员识别代码。

    进入cmd命令行,执行Python helloworld.py,看结果。

    注意文件名前面加python的原因是要把代码交给python解释器去解释执行

    内存和磁盘的关系:内存存取速度快,断电就丢失;磁盘存取速度慢,永久保存。

    Python交互器是主要用来对代码进行调试用的

    变量:先定义后使用

    变量作用:存数据,占内存,存储程序运行的中间结果,可以被后面的代码调用。

    声明变量:变量名=变量的值

    变量的命名规则:

    1.变量名只能是数字、字母或下划线的任意组合

    2.变量名的第一个字符不能是数字

    3.以下关键字不能声明为变量名[‘and’,‘as’,‘assert’,‘break’,‘class’,‘continue’,‘def’,‘elif’,‘else’,‘except’,‘exec’,‘finally’,‘for’,‘from’,‘global’,‘if’,‘import’,‘in’,‘is’,‘lambda’,‘not’,‘or’,‘pass’,‘print’,‘raise’,‘return’,‘try’,‘while’,‘with’,‘yield’]

    常量:程序在执行过程中不能改变的量

    在Python中没有一个专门的语法代表常量,程序员约定俗成的变量名全部大写代表常量。

    读取用户输入

    name = input(“what’s your name:”)print(“hello”+name)

    输入用户姓名和密码

    username= input(“username:”)

    password= input(“password:”)print(username,password)

    注释:解释说明,帮助阅读代码。

    单行注释:#

    多行注释:’’’…’’’

    数据类型

    数据类型-数字类型

    int(整型):32位机器上:-231 —— 231-1 64位同样的道理

    long(长整型):Python的长整型没有指定位宽。(Python3里不再有long类型)

    float(浮点型):

    数据类型-字符串类型

    字符串:在Python中,加了引号的字符都被认为是字符串!

    注意:单双引号是没有任何区别的;多行字符串必须用多引号。

    布尔类型:

    只有两个值True、False ,主要用来做逻辑判断

    格式化输出:(%s 以一个字符替换 %d以一个整数替换 %f以一个浮点数替换)都是一个占位符 %是一个连接符

    运算符

    算术运算符(+,-,*,/,%,**,//),

    比较运算符(==,!=,<>,>,<,>=,<=),

    逻辑运算符(and,or,not),

    赋值运算符(=,+=,*=,/=,%=,**=,//=),

    成员运算符(in,not in),

    身份运算符(is , is not),

    位运算(>>,<<)

    流程控制

    单分支:

    if 条件:

    满足条件后要执行的代码块

    多分支:

    if 条件:

    满足条件后要执行的代码块

    elif 条件:

    上面的条件不满足就走这个

    elif 条件:

    上面的条件不满足就走这个

    elif 条件:

    上面的条件不满足就走这个

    else:

    上面的条件不满足就走这个

    while循环

    while 条件:

    执行代码…

    Dead Loop

    count=0

    while True:

    print(“你个基佬!!!”,count)

    count+=1

    循环终止语句:break语句或continue语句

    break语句:用于完全结束一个循环,跳出循环体执行后面的语句

    continue语句:只终止本次循环,接着执行后面的循环

    while…else用法

    当while循环正常执行完,中间没有被break终止的话,就会执行else后面的语句。

    二进制运算、字符编码、数据类型

    二进制(0,1)、八进制(0-7)、十进制(0-9)、十六(0-9,A-F)进制的转换

    四位二进制表示一位十六进制

    oct() 八进制 hex()十六进制

    char(num)将ASCII值得数字转换成ASCII字符,范围只能是0-255

    ord(char)接受一个ASCII值字符,返回相应的ASCII值

    每一位0或1所占的空间单位为bit(比特),这是计算机中最小的表示单位

    8bits = 1Bytes字节,最小的存储单位,1bytes缩写为1B

    1024Bytes = 1KB = 1KB

    1024KB = 1MB

    1024MB =1GB

    1024GB = 1TB

    1024TB = 1PB

    ASCII 256,每一个字符占8位

    Unicode编码(统一码、万国码):规定了所有的字符和符号最少由16位表示

    UTF-8:ascii码中的内容用1个字节保存,欧洲的字符用2个字节保存,东亚的字符用3个字节保存…

    winsows系统中文版默认编码是GBK

    Mac OS\Linux系统默认编码是UTF-8

    UTF是为unicode编码 设计的一种在存储和传输时节省空间的编码方案。

    无论以什么编码在内存里显示字符,存到硬盘上都是二进制。不同编码的二进制是不一样的

    存到硬盘上以何种编码存的,那么读的时候还得以同样的编码读,否则就乱码了。

    python2.x默认编码是ASCII;默认不支持中文,支持中文需要加:#* coding:utf-8 * 或者 #!encoding:utf-8

    Python3.x默认编码是UTF-8,默认支持中文

    Python数据类型

    字符串 str

    数字:整型(int)长整型(long) 浮点型(float) 布尔(bool) 复数(complex)

    列表 list

    元组 tuple

    字典 dictionary

    集合:可变集合(set) 不可变集合(frozenset)

    不可变类型:数字,字符串,元组

    可变类型:列表,字典,集合

    899590-20180512120213031-26929447.png

    字符串

    特点:有序、不可变

    字符串的常用方法:isdigit,replace,find,count,index,strip,split,format,join,center

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 s = “abcd”

    2 print(s.swapcase()) #都变成大写字母

    3

    4 print(s.capitalize()) #都变成首字母大写

    5

    6 print(s.center(50,"")) #打印变量s的字符串 指定长度为50,字符串长度不够的用号补齐

    7

    8 print(s.count(“a”,0,5)) #统计字符串a在变量里有几个;0,5代表统计范围是下标从0-5的范围

    9

    10 print(s.endswith("!")) #是否是以什么结尾的。

    11

    12 print(s.startswith(“a”)) #判断以什么开始

    13

    14

    15 s = “a b”

    16 print(s.expandtabs(20)) #相当于在a和b中间的tab长度变成了20个字符,交互模式可看出效果

    17

    18 s.find(“a”,0,5) #查找字符串,并返回索引

    19

    20 s.format() #字符串格式化

    21 s1 = “my name is {0},i am {1} years old”

    22 print(s1)23 print(s1.format(“aaa”,22)) #分别把{0}替换成aaa {1}替换成22

    24 #也可以写成如下

    25 s1 = “my name is {name},i am {age} years old”

    26 s1.format(name=“aaa”,age = 22) #字典形式赋值

    27

    28 #s.format_map() #后续补充

    29

    30

    31 print(s.index(“a”)) #返回索引值

    32

    33 print(s.isalnum()) #查看是否是一个阿拉伯字符 包含数字和字母

    34

    35 print(s.isalpha()) #查看是否是一个阿拉伯数字 不包含字母

    36

    37 print(s.isdecimal()) #判断是否是一个整数

    38

    39 print(s.isdigit()) #判断是否是一个整数

    40

    41 print(s.isidentifier()) #判断字符串是否是一个可用的合法的变量名

    42

    43 print(s.islower()) #判断是否是小写字母

    44

    45 print(s.isnumeric()) #判断只有数字在里边

    46

    47 print(s.isprintable()) #判断是否可以被打印,linux的驱动不能被打印

    48

    49 print(s.isspace()) #判断是否是一个空格

    50

    51 print(s.istitle()) #判断是否是一个标题 每个字符串的首字母大写 Hello Worlld

    52

    53 print(s.isupper()) #判断是否都是大写

    54

    55 #s.join()

    56 name = [“a”,“b”,“1”,“2”]57 name2 = “”.join(name) #列表转成字符串,把列表里边的元素都join到字符串中

    58 print(name2) #得出ab12

    59

    60 #s.ljust

    61 s = “Hello World”

    62 print(s.ljust(50,"-")) #给字符串从左往右设置长度为50,字符串长度不够用 - 补充

    63

    64 print(s.lower()) #字符串都变成小写

    65

    66 print(s.upper()) #变大写

    67

    68 print(s.strip()) #脱掉括号里边的,可以是空格 换行 tab …

    69

    70 s.lstrip() #只脱掉左边的空格

    71 s.rstrip() #只拖点右边的空格

    72

    73 #s.maketrans() #

    74 str_in = “abcdef” #必须是一一对应

    75 str_out = “!@#$%^” #必须是一一对应

    76 tt = str.maketrans(str_in,str_out) #生成对应表,就像密码表一样

    77 print(tt)78 #结果:{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}

    79

    80 print(s.translate(tt)) #s.translate方法调用 加密方法tt 给 s的字符串加密

    81 #结果:H%llo Worl$

    82

    83 #s.partition()

    84 s = “Hello World”

    85 print(s.partition(“o”)) #把字符串用 从左到右第一个o把 字符串分成两半

    86 #结果:(‘Hell’, ‘o’, ’ World’)

    87

    88 s.replace(“原字符”,“新字符”,2) #字符串替换,也可以写换几次 默认全换,可以设置count次数

    89

    90 s.rfind(“o”) #查找最右边的字符,也有开始和结束

    91

    92 print(s.rindex(“o”) ) #查找最右边的字符的索引值

    93

    94 s.rpartition(“o”) #从最右边的字符开始 把字符串分成两半

    95

    96 s.split() #已括号里边的把字符串分成列表,括号里可以是空格、等字符来分成列表

    97

    98 s.rsplit() #从最右边以 某字符 来分开字符串

    99

    100 s.splitlines() #设置以换行的形式 把字符串分成列表

    101

    102 print(s.swapcase()) #字母换成相反的大小写,大的变成小,小的变成大

    103 #结果“:hELLO wORLD

    104 #原来的“hello World”

    105

    106 s.title() #把字符串变成title格式 Hello World

    107

    108 s.zfill(40) #把字符串变成40,字符串不够,从左往右用0 补齐

    109

    110

    111 #“a\tb” 字符串中间的\t 被认为是tab 是4个或者8个空格

    112 #整体意思是:a 有一个tab 然后 又有一个b

    View Code

    列表

    列表的常用方法:创建、查询、切片、增加、修改、删除、循环、排序、反转、拼接、clear、copy

    列表的特点:可以重复;列表是有序的

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 1、创建2 ​ 方法一:list1 = [“a”, “b”]   #常用

    3 ​ 方法二:list2 = list ()     #一般不用这种方法

    4

    5 2、查询6 ​ 列表的索引 (也称下标):7 列表从左到右下标是从0开始0、1、2、3…8 ​列表从右到左下标是从 - 1开始 -1 -2 -3…9

    10 ​查询索引值:11 ​list1.index (a)    #index查询找到第一个a程序就不走了,

    12 list1[0]    #通过a的索引 得出a

    13 list1[-1]   #通过b的下标 得出b

    14

    15 当list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]16 列表里出现元素相同时,统计相同次数17 list1.count (4)    #统计得出:6 代表列表有6个4

    18

    19 3、切片20 切片:通过索引 (或下标)21 截取列表中一段数据出来。22 list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]23 list1[0:2]    #得出 [1,2] ,列表切片顾头不顾尾,也可成list1[:2]

    24 list1[-5:]    #得出[4,4,4,4,4],取最后5个元素,只能从左往右取

    25 按步长取元素:26 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]27 list1[:6:2]    #得出:[1, 3, 5]   :2 代表步长 ,每隔两步取一个元素

    28 list1[::2]    #得出:[1, 3, 5, 1, 3, 5]  在列表所有元素中,每隔2步取一个数

    29

    30 4、增加31 list1 = [“a”, “b”, “c”]32 list1.append (“d”)    #追加d到列表list1的最后 结果:[‘a’, ‘b’, ‘c’, ‘d’]

    33 list1.insert (1, “aa”)    #插入aa到列表下标为1的之前   得出结果:[‘a’, ‘aa’, ‘b’, ‘c’, ‘d’]

    34

    35 5、修改36 list1[1] = “bb”    #直接给对应位置赋值,即是修改 结果:[‘a’, ‘bb’, ‘b’, ‘c’, ‘d’]

    37 批量修改38 把[‘a’, ‘bb’, ‘b’, ‘c’, ‘d’]里的前两个元素替换掉39 list1[0:2] = “boy”    #结果:[‘b’, ‘o’, ‘y’, ‘b’, ‘c’, ‘d’]

    40

    41 6、删除42 list1 = [‘b’, ‘o’, ‘y’, ‘b’, ‘c’, ‘d’]43 list1.pop ()    #默认删除最后一个元素 d

    44 list1.remove (“o”)    #删除元素O remove只能一个一个删除

    45 list1.remove (0)    #删除下标为0的元素 b

    46 del list1[0]    #删除下标为0的元素 del是一个全局删的方法

    47 del list1[0:2]    #del可以批量删除

    48

    49 7、for循环列表50 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]51 for i in list1: #使用for循环循环列表list1里边的元素

    52 range (10)    #生成0到10 的数字

    53

    54 8、排序55 list1 = [“1”, “5”, “3”, “a”, “b”, “f”, “c”, “d”, “A”, “C”, “B”]56 list1.sort () #结果:[‘1’, ‘3’, ‘5’, ‘A’, ‘B’, ‘C’, ‘a’, ‘b’, ‘c’, ‘d’, ‘f’]

    57

    58 排序是按照ASCII码对应排序。59 反转60 list1.reverse () #结果:[‘f’, ‘d’, ‘c’, ‘b’, ‘a’, ‘C’, ‘B’, ‘A’, ‘5’, ‘3’, ‘1’]

    61

    62 9、两个列表拼一块63 #方法一

    64 list1 = [1, 2, 3, 4, 5]65 list2 = [6, 7, 8, 9]66 list1 + list2 #结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]

    67 #​方法二

    68 list1.extend (list2)    #把列表2扩展到list1中

    69 结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]70

    71 10、clear72 #清空列表

    73 list2.clear ()    #清空list2

    74

    75 11、copy76 浅copy77 复制列表78 list2 =list1.copy ()79 当列表只有一层数据,没有列表嵌套列表的情况下,复制后的列表和原来的列表是完全独立的。80 当列表有多层嵌套的时候,列表嵌套里边的列表的内容是和原有列表是共享的。81 list1.copy () #所以这个叫做:浅copy

    82

    83 ​深copy:需要借助python模块84 importcopy85 list2 =copy.deepcopy (list1)86 深copy后,新的列表和旧的列表,不管有没有列表嵌套列表,都是完全独立的个体。87 可以通过查看列表名对应的内存地址分辨两个列表是否独立88 查看python解释器里边的内存地址:id (变量名)

    View Code

    元组

    特点:有序的,不可变的列表

    常用功能:index,count,切片

    使用场景:显示的告知别人,此处数据不可修改;数据库连接配置信息等

    hash函数

    hash,一般翻译为“散列”,也有直接翻译为“哈希”的,就是把任意长度的输入,通过散列算法,变成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不通的输入可能会散列成相同的输出,所以不可能从散列值来确定唯一的输入值,简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

    特征:hash值的计算过程是依据这个值的一些特征计算的,这就要求被hash的值必须固定,因此被hash的值必须是不可变的。(不能保证输出的数据唯一的,容易造成冲突)

    用途:文件签名;md5加密;密码验证

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 >>> hash(“abc”)2 -6784760005049606976

    3 >>> hash((1,2,3))4 2528502973977326415

    View Code

    字典

    语法:info={}

    特点:1.key-value结构,key必须是可hash、必须是不可变数据类型、必须唯一

    2.每一个key必须对应一个value值,value可以存放任意多个值,可修改,可以不唯一

    3.字典是无序的

    字典的查找速度快是因为字典可以把每个key通过hash变成一个数字(数字是按照ASCII码表进行排序的)

    字典的方法:增删改查 多级嵌套 等

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 #字典方法

    2 info ={3 “student01”:“aaa”,4 “student02”:“bbb”,5 “student03”:“ccc”

    6 }7

    8 #增加

    9 info[“student04”] = “ddd”

    10 info[“student05”] = “eee”

    11 info[“student06”] = “fff”

    12

    13 #查询

    14 #判断student01在不在info字典里

    15 print(“student01” in info ) #返回True

    16 print(info.get(“student01”)) #返回aaa,没有返回None

    17 info[“student01”] #获取对应的value ,如果没有这个key 就报错,所以一般用get

    18

    19 #删除

    20 print(info.pop(“student01”)) #删除key

    21 print(info.popitem()) #随机删除一个key

    22 del info[“student02”] #删除的key ,如果没有删除的key 就报错 KeyError: ‘student01’

    23

    24 info.clear() #清空字典

    25

    26 #多级字典嵌套

    27 dic1 = {“aaa”: {“aa”: 11}, “bbb”: {“bb”: 22}}28

    29 #其他方法

    30 info ={31 “name1”: [22, “it”],32 “name2”: [24, “hr”],33 “name3”: 33

    34 }35

    36 info2 ={37 “name1”: 44,38 “name4”: 33,39 1: 2

    40 }41 info.keys() #打印所有的key

    42 info.values() #打印所有的value

    43 info.items() #把字典转成一个列表

    44 info.update(info2) #把两个字典合成一个,如果有重复的key ,info2里边的重复key会覆盖info里边的key

    45 info.setdefault(“student07”,“abcdef”) #设置一个默认的key:value ,

    46 #如果info字典里没有key student07 ,那么info字典里有添加 student07:abcdef

    47 #如果info字典里已经手动添加了student07的key value,那么这里的student07:abcdef 就不起作用

    48 print(info.fromkeys([“name1”,“name2”],“aaa”) ) #从一个可迭代的对象中批量生成key和相同的value

    49

    50 #字典的循环:高效循环

    51 for k ininfo:52 print(k,info[k]) #打印key value

    53

    54 #另外一种方法 低效

    55 for k,v in info.items(): #先把字典转成列表,在循环,所以低效

    56 print(k,v)

    View Code

    集合

    集合是一个无序的、不重复的数据组合

    作用:1.去重

    2.关系测试,测试两组数据之间的交集、差集、并集等关系

    语法:

    s = {} #如果为空,就是字典

    s = {1,2,3,4} #就成了集合 set

    s = {1,2,3,4,1,2} #有重复数据,显示结果就直接去重{1, 2, 3, 4}

    列表转成给一个字典

    l = [1,2,3,4,1,2]

    l2 = set(l)

    集合的方法

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 #集合方法

    2 s = {1,2,3,4,5} #定义一个集合

    3

    4 #增加

    5 s.add(6)6 print(s) #{1, 2, 3, 4, 5, 6}

    7

    8 #删除

    9 #随机删除

    10 s.pop()11 print(s) #{2, 3, 4, 5, 6}

    12 #指定删除,如果不存在,就报错

    13 s.remove(6)14 print(s) #{2, 3, 4, 5}

    15 #指定删除,如果不存在,不报错

    16 s.discard(6)17 print(s)18

    19 #联合其他集合,可以添加多个值

    20 s.update([7,8,9])21 print(s) #{2, 3, 4, 5, 7, 8, 9}

    22

    23 #清空集合

    24 s.clear()25

    26

    27 #集合的关系测试

    28 iphone7 = {“alex”,“rain”,“jack”,“old_driver”}29 iphone8 = {“alex”,“shanshan”,“jack”,“old_boy”}30

    31 #交集

    32 print(iphone7.intersection(iphone8))33 print(iphone7 &iphone8)34 #输出:

    35 {‘jack’, ‘alex’}36 {‘jack’, ‘alex’}37

    38 #差集

    39 print(iphone7.difference(iphone8))40 print(iphone7 -iphone8)41 #输出:

    42 {‘rain’, ‘old_driver’}43 {‘rain’, ‘old_driver’}44

    45 #并集 把两个列表加起来

    46 print(iphone7.union(iphone8))47 print(iphone7 |iphone8)48 #输出:

    49 {‘rain’, ‘jack’, ‘old_driver’, ‘alex’, ‘shanshan’, ‘old_boy’}50 {‘rain’, ‘jack’, ‘old_driver’, ‘alex’, ‘shanshan’, ‘old_boy’}51

    52 #对称差集 把不交集的取出来

    53 print(iphone7.symmetric_difference(iphone8))54 #输出:

    55 {‘rain’, ‘old_driver’, ‘shanshan’, ‘old_boy’}56

    57 s = {1,2,3,4}58 s2 = {1,2,3,4,5,6,}59 #超集 谁是谁的父集

    60 print(s2.issuperset(s)) #s2是s的父集

    61 print(s2 >=s)62 #输出:

    63 True64 True65

    66 #子集

    67 print(s.issubset(s2)) #s是s2的子集

    68 print(s <=s2)69 #输出:

    70 True71 True72

    73 #判断两个集合是否不相交

    74 print(s.isdisjoint(s2))75 #输出:

    76 False #代表两个集合是相交的

    77

    78 s = {1,2,3,-1,-2}79 s2 = {1,2,3,4,5,6}80 s.difference_update(s2) #求出s和s2 的差集,并把差集 覆盖给 s

    81 print(s) #结果:{-2, -1}

    82

    83 s.intersection_update(s2) #求出s和s2的交集,并把交集 覆盖给 s

    84 print(s)85 print(s2)86 #结果:

    87 {1, 2, 3}88 {1, 2, 3, 4, 5, 6}

    View Code

    字符编码

    python3

    文件编码默认 :utf-8

    字符串编码:unicode

    python2

    文件编码默认:ascii

    字符串编码默认:ascii

    如果文件头声明了utf-8,那字符串的编码是utf-8

    unicode是一个单独的类型

    python3的内存里:全部是unicode

    python3执行代码的过程:

    1、解释器找到代码文件,把代码字符串按文件头定义的编码加载到内存,转成unicode

    2、把代码字符串按照python语法规则进行解释

    3、所有的变量字符都会以unicode编码声明

    在python2里边,默认编码是ASCII编码,那么文件头声明是utf-8的代码,在windows中将显示乱码

    如何在windows上显示正常呢?(windows的默认编码是gbk)

    1、字符串以gbk格式显示

    2、字符串以unicode编码

    修改方法:

    1.UTF-8 – >decode解码 --> Unicode

    2.Unicode – > encode编码 – > GBK / UTF-8

    ContractedBlock.gif

    ExpandedBlockStart.gif

    1 s=“路飞学城”

    2 print(“decode before:”,s)3 s2=s.decode(“utf-8”)4 print(“decode after:”,s2)5 print(type(s2))6 s3=s2.encoded(“gbk”)7 print(s3)8 print(type(s3))

    View Code

    python中bytes类型

    二进制的组合转换成16进制来表示就称之为bytes类型,即字节类型,它把8个二进制组成一个bytes,用16进制来表示。

    在python2里,bytes类型和字符串是本质上时没有区分的。

    str = bytes

    python2 以utf-8编码的字符串,在windows上不能显示,乱码。

    如何在python2下实现一种,写一个软件,在全球各国电脑上 可以直接看?

    以unicode编码写软件。

    s = you_str.decode(“utf-8”)

    s2= u"路飞"

    unicode类型 也算字符串

    文件头:

    python2:以utf-8 or gbk 编码的代码,代码内容加载到内存,并不会被转成unicode,编码依然是utf-8 或 gbk。

    python3:以utf-8 or gbk编码的代码,代码内容加到在内存,会被自动转成unicode。

    在python3里,bytes类型主要来存储图片、视频等二进制格式的数据

    str = unicode

    默认就支持了全球的语言编码

    常见编码错误的原因有:

    1、python解释器的默认编码

    2、python源文件文件编码

    3、终端使用的编码(windows/linux/os)

    4、操作系统的语言设置
    一、模块、包

    1、什么是模块?

    1、把相同功的函数放在一个py文件里,称为模块。

    2、一个PY文件就称为一个模块。

    3、模块有什么好处:

    1、容易维护。

    2、减少变量和函数名冲突。

    4、模块种类:

    1、第三方模块——别人写的模块

    2、内置模块——编译器自带模块(如:os、sys、等)

    3、自定义模块——自己编写的模块

    5、模块怎么导入:

    通过import命令导入,eg:import os(模块名)

    2、什么是包?

    1、把多个模块放在同一个文件夹内,这个文件夹称为包。

    2、文件夹称为包还有一个条件——文件夹里要有__init__.py模块。

    3、模块与包有什么区别

    1、模块——一个py文件就称一个模块

    2、包——一个包含有__init__.py的文件夹称为一个包;一个包里可以有多个py模块。

    json、pickle

    1、什么是序列化?

    1、把内存数据转换成字符串。

    1、把内存数据保存到硬盘。

    2、把内存数据传输给他人(由于网络传输是通过二进制传输,所以需要进行转换)。

    2、序列化的模块有两个,json和pickle

    2、json、pickle有什么优点和缺点?

    1、json——把json所支持的数据转换成字符串

    优点:体积小、跨平台。

    缺点:只支持int、str、list、dict、tuple等类型。

    2、pickle——把python所支持的所有类型转换成字符串

    优点:支持python 全部数据类型

    缺点:只能在python平台使用,占用空间大。

    3、json和pickle有4个方法

    load 、loads 、dump 、dumps

    load:通过open函数的read文件方法,把内存数据转成字符串

    loads:把内存数据转成字符串

    dump:通过open函数的write文件方法,把字符串转换成相应的数据类型。

    dumps:把字符串数据转成相应的数据类型。

    shelve

    1、什么是shelve?

    1、shelve是一种key,value 形式的文件序列化模块;序列化后的数据是列表形式。

    2、底层封装了pickle模块,支持pickle模块所支持的数据类型。

    3、可以进行多次反序列化操作。

    hashlib

    1、什么是hashlib?

    hashlib 模块——也称‘哈希’模块。

    通过哈希算法,可以将一组不定长度的数据,生成一组固定长度的数据散列。

    特点:

    1、固定性——输入一串不定长度的数据,生成固定长度的数字散列。

    2、唯一性——不同的输入所得出的数据不一样。

    2、md5

    输入一串不定长度的数据,生成128位固定长度的数据。

    特点:

    1、数字指纹——输入一串不定长度的数据,生成128位固定长度的数据(数字指纹)。

    2、运算简单——通过简单的运算就可以得出。

    3、放篡改——改动很少,得出的值都会不一样。

    4、强碰撞——已知MD5值,想找到相同的MD5值很难。

    函数

    1、什么是函数?

    把代码的集合通过函数名进行封装,调用时只需要调用其函数名即可。

    有什么好处:

    1、可扩展

    2、减少重复代码

    3、容易维护

    2、函数的参数?

    函数可以带参数:

    形参:

    1、在函数定义是指定。

    2、函数调用时分配内存空间,函数运行结束,释放内存空间。

    实参:

    1、形式可以是常量、变量、表达式、函数等形式。

    2、无论是何种形式,都必须要有明确的值,以便把数据传递给形参。

    默认参数:

    1、函数定义时可以指定默认参数(eg: def func(a,b=1))

    2、传参时指定了默认参数,就使用传参时的值,没有指定,则使用默认参数的值。

    关键参数:

    1、函数传参时需按顺序传参,如果不按顺序传参可以使用关键参数传参。

    非固定参数:

    1、当不确定参数的数量时可以使用非固定参数。

    2、非固定参数有两种:1.*args——(传入的参数以元组表示)。2.**kwargs——(传入的阐述用字典表示)

    3、函数的返回值

    1、函数可以把运算的结果返回。

    2、函数可以有返回值,也可以没有返回值。

    有返回值——通过return返回。

    没有返回值——返回值为None

    3、函数遇到return,代表函数运行结束。

    4、函数的种类

    嵌套函数——一个函数包含了另一个函数。

    高阶函数——一个函数的参数引用了另一个函数,一个函数的返回值是另一个函数。

    匿名函数——不用显式指定函数名的函数(lambrda),常和map和filter配合使用。

    递归函数

    1、函数内部引用了函数自身

    2、函数里有一个明确的结束条件。

    递归函数的特性:

    1、有一个明确的结束条件

    2、每次递归的规模都应有所减少

    3、递归函数的效率不高。

    作用域

    1、名称空间

    名称空间就是存放变量名和变量值(eg:x=1)绑定关系的地方。

    1、名称空间种类:

    local:函数内部,包括形参和局部变量。

    global:函数所在模块的名字空间。

    buildin:内置函数的名字空间。

    2、变量名的作用域范围的不同,是由这个变量名所在的名称空间所决定的。

    全局范围:全局存活,全局有效。

    局部范围:局部存活,局部有效。

    2、作用域查找顺序

    作用域查找顺序:

    local——》enclosing function——》global——》builtin

    local:函数内部,包括形参、局部参数。

    enclosing function:内嵌函数。

    global:函数所在模块。

    builtin:内置函数。

    闭包

    1、什么是闭包

    1、一个嵌套函数,分别有内函数,外函数。

    2、内函数使用了外函数的变量。

    3、外函数返回了内函数的应用地址。

    4、那么这个嵌套函数就称为闭包。

    2、闭包有什么意义

    1、闭包返回的对象不仅仅是一个对象,而且还返回了这个函数的外层包裹的作用域。

    2、无论这个函数在何处被调用,都优先使用其外层作用域。

    装饰器

    1、什么是装饰器

    1、装饰器本质上就是一个闭包函数。

    2、装饰器的作用是,在不改变原有函数的调用方式下,增加代码的功能。
    不喜勿喷,喜欢的点个赞呗!

    展开全文
  • C语言知识点

    千次阅读 多人点赞 2016-05-27 22:54:31
    语言的基础知识 第一节、对 C 语言的基础认识 1 、 C 语言编写的程序称为源程序 , 又称为编译单位 。 2 、 C 语言书写格式是自由的,每行可以写多个语句,可以写多行。 3 、一个 C 语言程序有且只有一...
  • 知识点整理,MySQL面试题

    万次阅读 多人点赞 2020-03-11 12:28:25
    整理了一些互联网大厂的面试题,这些面试题经常会被问到,也是作为Java工程师需要掌握的一些知识点,毕竟理论和实践的结合,才是王道,分片整理,每天嗑些知识点,快乐每一天,如果对你有帮助,记得点个关注和点个赞...
  • 知识点汇总【一】操作系统三十八问
  • 通信工程专业的一些小知识点

    千次阅读 2019-04-25 14:11:49
    通信工程专业的一些小知识点 - 子木的文章 - 知乎 https://zhuanlan.zhihu.com/p/49285829 一、 无线信道的多径效应导致的频率选择衰落 总的来说,这属于“静”,所谓静,就是指发送和接收终端、以及导致电磁波的...
  • 大学物理(下)知识点总结

    千次阅读 多人点赞 2020-10-01 21:17:08
    大学物理(下)知识点总结(持续更新) 文章目录大学物理(下)知识点总结(持续更新)静电场知识点总结习题精选 静电场 需要掌握的重难点:电通量的高斯定理,电势的两种求法。 知识点总结 1、电荷守恒定律 在一个...
  • 关于JVM系列面试知识点总结了一个思维导图,分享给大家 内存结构 线程共享区域 堆(用于存放对象实例) 1、新生代 (1)Eden区 (2)Survivor(from)区(设置Survivor是为了减少送到老年代的对象 ) (3)...
  • 高等代数-知识点

    千次阅读 2020-07-03 17:20:28
    考研:小题,无法联系其他知识点,当场解决。 3、二阶、三阶行列式具体计算 考研:不会单独出题,常常结合伴随矩阵、可逆矩阵考察。 4、余子式和代数余子式 考研:代数余子式的正负是一个易错点,了解代数余子式...
  • CAN总线知识点梳理

    千次阅读 2017-05-11 14:54:55
    CAN总线知识点梳理
  • RFID知识点

    千次阅读 2019-12-22 15:53:48
    1.RFID的概念,特点,组成 无线射频识别作为一种通信技术,可通过无线电讯号...RFID技术特点 1快速扫描 2体积小型化、形状多样化 3抗污染能力和耐久 4可重复使用 5穿透和无屏障阅读 6数据的记忆容量大 7安全...
  • 线性代数知识点总结

    千次阅读 2019-11-24 14:18:40
    线性代数知识点总结 本文秉承着“将书读薄”的思想将《线性代数》和《程序员的数学——线性代数》中的知识点进行凝练总结,以便以后时常复习。 —————————————————————————————— ...
  • 浙大数据结构mooc知识点总结

    千次阅读 多人点赞 2019-03-16 19:05:59
    如果T1可以通过若干次左右孩子互换就变成T2,则我们称两棵树是“同构”的。 二叉搜索树 平衡二叉树 堆 完全二叉树实现的优先队列 哈夫曼树 并查集 ...
  • java工程师-面试知识点总结

    千次阅读 2018-02-22 17:45:10
    目录 [x] 一、Java基础(语言、集合框架、OOP、设计模式等) [x] 二、Java高级(JavaEE、框架、服务器、工具等) [x] 三、多线程和并发 [x] 四、Java虚拟机 [x] 五、数据库(Sql、MySQL、Redis等) ...
  • Java知识点总结

    万次阅读 2017-03-08 16:06:14
    Java研发工程师知识点总结 大纲  一、Java基础(语言、集合框架、OOP、设计模式等) 二、Java高级(JavaEE、框架、服务器、工具等) 三、多线程和并发 四、Java虚拟机 五、数据库(Sql、MySQL、Redis...
  • 数据结构知识点

    千次阅读 多人点赞 2018-09-07 14:32:51
    输入、输出、有穷、确定、可行 输入输出:算法具有输入和输出 有穷:算法不会出现无限循环,并且每个步骤可在可接受时间内完成 确定:每个步骤都有确定的含义 可行:算法的每一步都是可行的...
  • Android知识点原理总结

    千次阅读 2020-04-24 08:00:50
    总结常用知识点 Activity 4种启动模式 要讲启动模式,先讲讲任务栈Task,它是一种用来放置Activity实例的容器,他是以栈的形式进行盛放,也就是所谓的先进后出,主要有2个基本操作:压栈和出栈,其所存放的Activity...
  • 文件操作知识点摘记

    2015-12-18 14:13:41
    对于文件操作,主要知识点经验总结如下。 1.
  • C++11知识点总结(全面解析C++11经常考到的知识点

    千次阅读 多人点赞 2020-04-28 17:43:22
    1. C++11简介 相比于C++98/03,C++11则带来了数量可观的变化,其中包含了约140个新特性,以及对C++03标准中约600个缺陷的修正,这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言,C++11能更好地用于...
  • 知识点 8 基因突变和基因重组 一选择题 60 O 1. 扬州高一检测放射同位素 C 能够产生 射线高速运动的 射线作用于 DNA能够 使氢键断裂 . 碱基替换从而有可能诱发生 物产生 A. 基因突变 B. 基因重组 C. 基因互换 D. ...
  • 线代知识点

    2019-12-07 00:10:28
    一、行列式 n阶行列式: ...1、行列互换,其值不变 2、行列式中某行/列元素全为0,则行列式为0 3、行列式中某行/列元素有公因子k(k不为0),则k可提到行或列外面 4、行列式某行/列元素均是两个...
  • Java知识点

    千次阅读 2014-09-25 10:14:17
    多态包括参数化多态和包含多态。多态语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。 二:int 和 Integer 有什么区别 Java 提供两种不同的类型:引用...
  • JAVA语言知识点总结

    千次阅读 多人点赞 2019-10-09 11:33:50
    通常哪些设为安全? 14、GC中如何判断对象需要被回收? 一个方法中有A a = new A();这么一条语句,方法执行完后A的实例化对象在GC时能否被回收掉 15、GCRoot可以是哪些对象 16、什么时候会触发full gc? FullGC是否...
  • 通信原理 面试题知识点复习

    万次阅读 多人点赞 2020-07-05 21:26:29
    (3)扩展信号带宽,提高系统抗干扰、抗衰落能力,还可实现传输带宽与信噪比之间的互换。 线性调制与非线性调制(了解) 角度调制与线性调制不同,已调信号频谱不再是原调制信号频谱的线性搬移,而是频谱的非线性...
  • C基本知识点拾遗

    2017-01-05 15:17:38
    最近需要学习C语言,找了些C容易犯错的知识点和重点,以提示自己。 总体上必须清楚的:  1)程序结构是三种: 顺序结构 、选择结构(分支结构)、循环结构。  2)读程序都要从main()入口, 然后从最上面顺序往下读...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,783
精华内容 5,513
关键字:

互换性知识点