精华内容
下载资源
问答
  • 工厂模式通过封装一个函数来创建对象,所有的对象都是相同的,缺点是无法赋予一个对象特定的类型 构造函数模式 原型模式

    工厂模式

    通过封装一个函数来创建对象,所有的对象都是相同的,缺点是无法赋予一个对象特定的类型

    function createObject(name,age,job) {
        var o=new Object();
        o.name=name;
        o.age=age;
        o.job=job;
        return o;
    }
    var person=createObject("John","19","teacher");
    

    构造函数模式

    这种方法没有显示地创建对象,而是通过this绑定对象。
    按照惯例构造函数名以大写字母开头

    function Person(name,age,job) {
    
        this.name=name;
        this.age=age;
        this.job=job;
        this.say=function(){
            alert("hello");
        }//每定义一个Person对象都会实例化一个匿名函数对象
    }
    var person1=new Person();//通过new来创建对象
    alert(person1.constructor==Person);//true
    alert(person1 instanceof Object);//true
    alert(person1 instanceof Person);//true

    这样定义的对象会有一个constructor属性

    原型模式

    创建的函数都有一个prototype属性,这个属性是一个指针,指向原型对象

    function Person() {
        Person.prototype.name="John";
        Person.prototype.age="18";
        Person.prototype.sayName=function () {
            alert(this.name);   
        }
    }
    var person1=new Person();
    alert(person.name);//"John"
    alert(Person.prototype.constructor==Person);//true
    alert(Person.prototype.isPrototypeOf(person1));//true

    person1这个对象会有一个属性{[prototype]}指向Person.prototype,
    但person1这个对象和Person函数之间没有直接联系

    接下来谈谈关于原型的一些方法

    • hasOwnProperty() 实例属性返回true,原型属性返回false;
    • in 对象能访问该属性时返回true,无论实例属性还是原型属性都一样
    alert("name" in person1);//true
    • for in 循环返回能够通过对象访问的可枚举的属性(包括原型中和实例中的),如果实例属性覆盖了原型中不可枚举的属性,该实例属性也会返回,但是在IE8以及更早的版本中,该实例属性不会返回。
      不可枚举的属性和方法有:
      • hasOwnProperty();
      • propertyIsEnumberable( );
      • toLocaleString( );
      • toString( );
      • valueOf( );
    • keys( ) 返回对象所有可枚举的实例属性,对象作为参数,返回值是一个可枚举属性的字符串数组,顺序与for in相同
    • Object.getOwnPropertyNames( ) 返回所有实例属性,无论能否枚举 (IE9+,Firefox4+,Safari5+,Opera12+,Chrome支持以上两个方法)

    原型的其他写法

    function Person() {
    
    }
    Person.prototype={
        name:"John",
        age:20,
        job:"Doctor"
    };

    这样写constructor不在指向Person
    可以在Person.prototype中显式的声明constructor,但这样这个属性会变成可枚举的,可以用Object.defineProperty( )替代,这个方法适用于兼容ES5及以上的浏览器

    Object.defineProperty(Person.prototype,"constructor"
    ,{
    enumberable:false,
    value:Person
    });
    

    原型的动态性
    原型的动态性在于可以在通过原型方法定义对象后,修改原型,此时对象也会相应变化
    但是如果重新定义原型,对象与新原型之间则没有联系,原因在于,对象与构造函数之间是没有之间联系的

    最后的问题是可以修改对象的原型属性达到修改原型的目的

    展开全文
  • 所有的HTML元素都由HTMLElement类型表示,HTMLElement类型继承自Element... id title dir lang className 操作特性 ...操作特性的三个方法 ...这三个方法可操作所有特性,包括之前提到的5个属性以及自定义特性;...但是自定...

    所有的HTML元素都由HTMLElement类型表示,HTMLElement类型继承自Element并添加了一些属性,包括:

    • id
    • title
    • dir
    • lang
    • className

      操作特性

      操作特性的三个方法

    • getAttribute();
    • setAttribute();
    • removeAttribute();

      这三个方法可操作所有特性,包括之前提到的5个属性以及自定义特性;
      但是自定义特性不能通过属性方法访问,即不能通过.来访问

     <div id="my_id" my_special="special"></div>
    alert(div.id);            //"my_id"
    alert(div.my_special);    //undefined(IE除外)

    例外

    • style:通过getAttribute()访问得到css文本,通过属性方法访问得到对象
    • onClick:通过getAttribute()访问的到函数的字符串,通过属性方法访问的到函数

      setAttribute()方法对于不存在的特性会自动创建

    div.my_color="red";
    alert(div.getAttribute("my_color")); //null(IE除外)

    attributes

    这个属性包括了所有特性的集合

    childNodes

    IE会包括所有子节点以及由空白符组成的文本节点,其他浏览器不会

    展开全文
  • 高级语言程序设计(C语言) 第一章.计算机的发展 世界上第一台计算机 1946年 美国:ENIAC电子数字积分计算机 电子管为主要元件 ,冯.诺依曼提出存储程序概念和二进制思想; 1.四个发展时代 1>第一代 :20世纪50年代,...

    高级语言程序设计(C语言)

    第一章.计算机的发展
     世界上第一台计算机 1946年 美国:ENIAC电子数字积分计算机 电子管为主要元件 ,冯.诺依曼提出存储程序概念和二进制思想;
    1.四个发展时代
      1>第一代 :20世纪50年代,主要采用真空电子管制造计算机
      2>第二代:20世纪50年代末期:出现了以晶体管为主要元件的第二代计算机;
      3>第三代:1964年,IBM公司推出IBM360系列计算机垄断了60%~70%的国际市场,它的出现标志着计算机进入第三代;
      4>第四代:随着大规模集成电路和微处理器的出现,计算机进入第四代;
      
    2.计算机语言
     1>机器语言:由二进制代码表示的能被计算机识别和执行的指令集合.如1000000加
    
     2>汇编语言:
       *1.利用助记符代替机器语言,同时具有占用存储空间较少,执行效率高的优点add a,b
       *2.在汇编阶段,汇编程序 将 汇编语言编写的程序(源程序) 进行汇编,
    	  转换为生成一个可重定位目标文件(目标程序);
    	 
     3>高级语言:
       *1.使用高级语言编写的程序称为"源程序",源程序无法被计算机直接运行.
    	    必须翻译为二进制程序(目标程序)后才能执行;
    		
       *2.翻译程序通常有两种工作方式
    	 
    	 ①.编译方式:将源程序全部翻译成二进制代码(目标程序),然后再执行;先写完再翻译
    	   在此完成翻译工作的程序称为“编译程序”(编译程序)
    				   
    	 ②.解释方式,翻译一句执行一句,边解释边执行(Basic语言);同步翻译,(解释程序)
    	   
       *3.世界上第一个高级语言是Fortran语言,目前广泛运用的高级语言有c/c++,java和C#;
    	 
    3.算法
     1>概念:解决问题的步骤序列就是算法;
      
     2>算法必须具备的五个特征:
       ①.可执行性(语法正确)
       ②.确定性(符合逻辑的)
       ③.有穷性(不能死循环)
       ④.有输入信息说明(有注释)
       ⑤.有输出信息的步骤;(每步都比较清晰)
       
     3>算法描述方法
      *1.自然语言(母语描述(文字)) 比较冗余,易出现歧义;
       
      *2.传统流程图:
         流程图是一些图形表示各种操作,用图形描述算法形象直观,易于理解.
    	 
      *3.N~S流程图
         三种基本结构:顺序结构,选择结构,循环结构.
    	 ①.顺序结构:A->B
    	  
    	 ②.选择结构:
    	   二分支选择结构:(true P(判断条件) false) if(){}else{};
    	   多分支选择结构: if()else if()else{};  switch case 语句
    	  
    	 ③.循环结构:
    	   当型循环结构:when();p的true和false  为true就执行循环, false就停止循环
    	   直到型循环: for(i=0,i<sum,i++);
    		  
      *4.伪代码
         是用介于自然语言和机器语言之间的文字和符号描述的算法.
       
      *5.计算机语言(高级语言)
         计算机是无法识别流程图和伪代码的,只有计算机语言编写的程序才能被计算机执行;
    	  
    4.计算机程序
     1>概念:简称程序,是根据算法描述,用计算机语言表示的能被计算机识别和执行的 指令集合 ;
       
       //this is a c program
       #include<stdio.h> //头文件 相当于import 导入库; 编译预处理
       void main(){
    		printf("this is a c program.\n");
       }
       
    5.结构化程序设计方法的优点:
     1>采用 "自顶向下,逐步求精" 的结构化程序设计方法使得整个设计方案层次分明,
       可以 "先易后难,先抽象后具体" 使得整体程序设计工作,思路清晰,目标明确;
    	
     2>程序由 "相互独立的模块" 构成,在设计模块时不会受到其他模块的牵连;
      
    6.面向对象程序设计 (自顶向下,逐步求精)
      与传统的结构化设计思想的区别:
      1>面向对象方法采用数据抽象和信息隐藏技术(封装)使组成类的数据和操作是不可分割的.
        避免了结构化程序由于数据和过程分离引起的弊病;
       
      2>面向对象的程序由类和对象(类的实例)和对象之间的动态联系组成的.
        而结构化程序是由结构化数据,过程的定义以及调用过程处理相应的数据组成的.
    
    第二章.C语言的基本知识
    1.C语言发展
       ALGOL60(20世纪60年代)->CPL组合程序设计语言(1963年) ->BCPL基本CPL(1970)->B语言->C语言(1972)
       UNIX(1975)->正式(1978),83ANSIC  C语言标准草案(1983)->C90(1990)-->C99(1999) 后面都是国际化  
    
    2.C语言基本词法 
     *1.字符集:
      1>字符是组成语言最基本的元素.C语言的字符集由,字母,数字,空格,标点和特殊字符组成;
        C语言的字符集就是ASCII字符集,主要包括:
    	*1.阿拉伯数字:0,1,2...,9(共10个);
    	*2.大小写英文字母:A~Z,a~z(共52个);
    	*3,非字母,非数字的可显示字符(33个);
      2>关键字(小写)
       *C语言区分大小写(敏感大小写)
       C语言中具有特殊含义的单词称为"关键字",又称"保留字",主要用于构成语句.
       C语言共有 32 个关键字,所有的关键字均由小写字母组成;(由系统定义,不能用作其他定义);
       
       if else switch case break default  for do while continue return  void(无返回数)
       
       char int short long float double enum extern(外部变量) const(常量) static
       
       register(寄存器) signed(有符号(-,+)) unsigned(无符号) sizeof(计算字节数)  
       
       typedef(类型定义) struct(结构) union/'juːnjən/(共用)  volatile /'vɒlətaɪl/(可变的)  
       
       auto(自动)    goto(转向)
    
      3>标识符
      
      *1.用途:
        标识符是字符的序列,除了库函数的函数名等由系统定义外,其余均由用户自行定义,
        用户根据需要对C程序中用到的变量,符号变量,自定义函数等进行命名,形成用户标识符.
    
      *2.概念:标识变量名,符号常量名,函数名,数组名,文件名的字符串序列; 
    
      *3.规则: 
       ①.用户标识符仅由 大小写英文字母,数字和下划线组成,且第一个字符不能是数字;
    	②.大小写字母含义不同,一般用小写;
    	③.用户定义的标识符既不能是C语言的关键字,也不能与用户编写的函数或C语言的库函数重名;
        *.标识符应该"见名知意,不易混淆";
      *4.使用: 先定义,后使用;
    
    3.C语言的特点:
     1)结构化语言
     2)运算能力强大
     3)数据类型丰富
     4)具有预处理能力
     5)可移植性好
     6)程序执行效率高
     7)程序设计自由度大
       
    4.分割符
      C语言的分割符包括逗号(",")和空格(" ")两种,
      1>逗号主要用于在类型说明和函数参数表中, int a,b;
      2>分割各个变量;空格多用于语句各单词之间,作为分割符;int num;
      3>语句的分割为分号(";")
    	
    5.常量
      符号常量:用标识符代表常量:
      1>一般用大写字母:PERICE、PI(π);
       
      2>定义格式:#define 符号常量 常量;
       
      3>其值在作用域内不能改变和再赋值;
       
      4>符号变量的优点是:见名知意,一改全改;
       
       #define PRICE 30
       #include<stdio.h>
       void main(){//程序的入口;
    	 int num,total;//先声明,是为了分配存储空间
    	 num=10;
    	 total=num*PRICE;
    	 printf("total=%d\n",total")
       }
    
    6.C语言基本语句分类
       按语句功能或构成的不同,可将C语言分为 
       
       数据定义语句(定义变量), 
       
       赋值语句(从右往左读), 
       
       函数调用语句(调用方法),
       
       表达式语句(if()else{},switch case..), 
       
       流程控制语句(goto),
       
       复合语句(代码块{})
       
       空语句(接口)
       
       C语言的每个语句都以分号结束;
       
       scanf:标准的输入函数;
       printf:标准的输出函数;
       
       &a的含义是取a的地址,&"取地址"
       
       #index<stdio.h>
       void main(){
         int max(int x,int y)声明函数,如果max函数在main函数上面,该行可省略;
    	 int a,b,c;
    	 scanf("%d,%d"&a,&b);
    	 c=max(a,b);
    	 printf("max=%d",c);
       }
       
       int max(int x,int y){
    	 int z;
    	 if(x>y)z=x;
    	 else z=y;
    	 return (z);
       }
       
    7.C程序的基本组成及特点
     
      1>每个C程序由一个或多个函数组成,每个C程序有且只有一个主函数,其函数名为main,
    	  除主函数外,可以没有其他函数,也可以有一个或多个其他函数.
    	
      2>函数 是C程序的基本单位,每个函数是由函数首部和函数体两部分组成.
    	
      3>C程序中每一语句后面都以分号";"作为语句的结束,但预处理命令,函数首部和
    	  右花括号"}"之间不能加分号.void main(){}
    	  
      4>C语言本身没有输入/输出语句,而是通过调用库函数scanf()、printf()、
    	  getchar()和putchar实现的;
    	  
      5>C程序的任意位置都可以加注释/*...*/,注释可以多行但不可以嵌套;
    	
      6>C程序的书写格式灵活,一行内可书写多条语句,一条语句也可以写在多行上,
    	  可以任意插入空格和回车;
    	  
      7>C程序的执行总是从主函数开始,并在主函数结束.主函数和其他函数的位置是任意的,
    	  其他函数总是通过函数调用语句被执行;
    	  
      8>C程序中可以有预处理命令,通常预处理命令应放在程序的最前面.(#define,#include)
    	
      9>主函数可以调用任何其他函数,任何其他函数之间可以相互调用,但不能调用主函数;
    	
     8.C语言格式特点
       
    	1>习惯用小写字母,大小写敏感;
    	
    	2>不使用行号,无程序行概念;
    	
    	3>可使用空格和空行;
    	
    	4>常用锯齿形书写格式
    	
    	**.编程规范
    	 1>使用Tab缩进;
    	 
    	 2>{}对齐;
    	 
    	 3>有足够的注释;
    	 
    	 4>有合适的空行;
    	 
     9.C程序的开发环境(运行步骤)
     
    	1>编辑: 进入C语言编译系统,建立源程序文件,扩展名为"c"或"cpp",
    	编辑并修改,保存源程序,
    	
    	2>编译: 计算机不能识别和执行高级语言编写的源程序,必须经过 编译程序 对源程序
    	  进行编译.
    	  
    	3>连接: 经过编译生成的目标程序还无法在计算机上直接运行,因为源程序中输入,输出
    	  以及常用的海曙运算是直接调用的函数库中的库函数,因此必须把库函数的处理过程
    	  链接到经编译生成的目标程序中,生成可执行文件,其扩展名为"exe".
    	  
    	4>运行: 一个C源程序经过编译,链接后生成可执行文件,可在编译系统或操作中运行;
       
     10.编辑步骤:
     
      File->New->Files->C++ source file->Add to project->空工程(工程名)->File(hello.c)->Ok
      
    第三章 数据类型,运算符和表达式
     1.数据类型
     
      1>概念:数据既是程序加工和处理的对象,也是程序加工和处理的结果;
      
      2>分类:
        
    	*1.基本类型:整型,浮点型(实型),字符型和枚举四种;
    	
    	*2.构造类型是由基本数据类型按一定规则组合而成的复杂数据类型,
    	   包括数组型,构造体类型和共用体类型;
    	   
    	*3.指针类型是一种更加灵活的数据类型,用来表示内存地址;
    	
    	*4.空类型是从语法完整性角度给出的数据类型,表示不需要数据值,因而没有类型;
    
      																   有符号短整型 short 
    												有符号整型	   有符号的基本整型 int	E1=10;(E就是10)
    									   							有符号的长整型 long
    						整型							 
    																  无符号短整型 
    			 基本类型						无符号整型	  无符号的基本整型
    															     无符号的长整型
    			   										 单精度型float
     									实型(浮点型)
      数														 双精度型 double
      据							 	   字符型 char ASCII码值
      类									枚举型enum
      型							  数组类型
    			 构造类型	  结构体类型								*.数据类型决定
    	  共用体类型								 1>数据占内存字节数
    			 指针类型: 用来表示内存地址		  						 2>数据取值范围
          空类型void													 3>可以进行的操作
    
     2.常量
      1>字符char常量
        *. \n 回车换行,  \r回车   \0空字符   \’单引号   \ddd 1~3位八进制进制代表的字符,例:\103,代表’C’
        *. \t 横向跳下一制表符  \f 换页  \b 左退一格  \\ 反斜杠  \” 双引号 \Xhh 1~2位16进制代表的字符
        *, C语言中空字符和空格符不同,空字符转义符用”\0”表示, 空格符是ASCII字符集中一个可显示字符,值为32;
      2>字符串常量(用字符数组来存放)
        编译时再字符串的末尾加一个转义字符’\0’,作为字符串结束标志,即长度为n个字符的字符串占n+1个字节;
        也就是说字符串除了存储有效的字符外还要存储一个字符串结束标志’\0’; “abc”,声明字符数组时是char[4]
    
      3>符号常量
        #define 符号常量 一般放在程序的开头,每个定义必须独占一行,因为不是语句,没有”;” 例如:#define PRICE 30
        特点:其值在作用域内不能改变和再赋值.
          #define PRICE 30 //符号常量
          #include <studio.h>
          Void main(){
           int num, total;
           total=num*PRICE;
         }
      使用符合常量的优点:
      *1.提高程序的可读性;
      *2.便于程序修改;
    
     3.变量
      *1.定义:其值可以改变的量, 数据类型 变量名; 
      *2.变量应该有名字,并在内存中占据一定的存储单元;
      *3.变量名和变量值有不同的含义(变量名为一个符号地址,)
       1>整型变量
         有符号的:int short long   无符号的:unsigned,unsigned short, unsigned long,(无符号的都为正数)
       2>实型变量(浮点型)
         *1.单精度:float,一般占用内存4字节,保留6~7位有效数字(a=123456.789  实际a的值为123456.7位).
         *2.双精度double,一般占用内存8字节,保留15~16位有效数字(b=123456.789,实际b的值为123456.789)
         *3.有效数字:从左边第一位非0数字起,开数,小数点不算;
       3>字符型变量,占1字节,需要注意字符串只能是常量,C语言中没有字符串变量,而是用字符数组存放字符串变量;
       4>变量的定义:
          *1.被定义为整型(包括int short和long)的变量,若其值为-128~127,则可以作为字符型变量使用;
          *2.被定义为无符号整型(包括unsigned、unsigned short, unsigned long,)的变量,
             若值为0~255,也可以作为字符型变量使用;
          *3.变量初始化:可以在定义是赋初值;编译程序根据变量定义为其分配指定字节的内存单元;
          *4.先声明(在内存中开辟存储空间),再赋值
    	  Int a=1; short s=8;
    
    4.运算符:
     1>运算符的分类
      	     	 算术运算符:(+  -  *  /  %  +(取正)   –(取负) )
      		  	 自增,自减运算符: ++  --
      	    基 	 关系运算符: (<  <=   ==   >   >=   !=)
      	    本 	 逻辑运算符:  !   &&   ||
      运		运 	 位运算符: <<  >>  ~  |   &
      算		算 	 赋值运算符 (=  +=  -=  *=  /=)
      符      符 	 条件运算符(?:)
             	     逗号运算符(,)
      		  	 数据长度运算符 (sizeof)
    
      		 	 强制类型转换 (类型)
      		专 	 成员运算符:( .  ->)
      	    用	 下标运算符([ ])
              	 指针运算符(* &)
    
     2>学习运算符应注意:
       *1.运算符功能;;
       *2.与运算量的关系;
          ①.要求运算量个数
          ②.要求运算量类型
       *3.运算符优先级别;
       *4.结合方向;
          *除单目运算符(只有一个变量参与运算),赋值运算符和条件运算符是右结合之外,其他的运算符都是左结合.
       *5.结果的类型;
    
     3>C语言运算符的优先级的排序
       1.  () [] ->(指针运算) . 从左至右
       2.  !  ~  ++  --  *(取内容)   &(取地址)  +(取正)  -(取负)  sizeof    从右至左计算;
       3.  *(乘)  /  %(运算变量必须为整数)
       4.  +(加)  -(减)
       5.  <<  >>
       6.  <  <=  >  >=
       7.  ==  !=
       8.  &(位逻辑与)                           从左至右
       9.  ^(异或)
       10.  |(位逻辑或)
       11.  &&
       12.  ||
       13.  ?:   从右至左
       14.  =  +=  -=  *=  /=  %=  &=  ^=  |=  >>=  <<=  从右至左
       15.  ,  从左至右
    
     4>自增和自减 运算符
       *1.如果 ++ 或 – 在前面就自增(减)后再参加运算;
       *2.如果 ++ 或 – 在后面就先不自增(减)运算完成后再自增(减);
        例: int a=2; int b=3;
        (a++)+(++b)=2+4=6;然后a+1=3, ++在后不参与运算,(运算结束后起作用)
    
     5>复合赋值运算符
        a+=3;=> a=a+3  (两边等价)
      1)10进制转为2进制, (将需要的数记为1,不需要的记为0)
        1024  512  256  128  64  32  16  8  4  2  1
      2)10进制转为2进制, (将需要的数记为1,不需要的记为0)
          1024  512  256  128  64  32  16  8  4  2  1
       例:47==>                 0   1   0  1  1  1  1
         如果是1byte(8位), 47就是0010 1111 (补了1位)
         1byte 8位  如果10进制转为2进制后位不够就补0;
    
      3)16进制 1 2 3 4 5 6 7 8 9 a(10 )b(11) c(12) d(13) e(14) f(15);
    
      4)10进制  8进制  2进制 等
       *1.将一个x进制整数anan-1..a1,转化成10进制的公式;
          anan-1..a1=an*X(n-1)+an-1*X(n-2)+...a2*X+a;
          例.0x11a=1*16^2+1*16^1+a*16^0=256+16+10=282;
    
       *2.只计算其位不为0的数值;
    
       *3.将一个10进制整数a,转换为一个x进制整数的公式: a/x取余,商/x取余,知道商为0,所有余数逆序即为x进制数;
    
       *4.将一个10进制浮点数转换为一个2进制整数公式;
          整数和小数分别转换,整数部分/2取余(商为0结束),小数部分*2取整(积的小数部分为0结束);
    
    
     6>位移运算
       <<  (左移n位是乘以2的n次幂);
       >>  (右移n位是除以2的n次幂);
    
    5.数据类型转换:
      原则: 就高不就低或就长不就短
      高     double       float
    
               long
    
      	unsigned
    
      低	int           char ,short
    
    第四章 结构化程序设计
    1.结构化程序设计方法
      1)自顶向下,逐步求精
      2)模块化设计
      3)结构化编码:经模块化设计后进入编码阶段,任何程序都由顺序、选择和循环三种基本结构组成;
    
    2.结构化程序三种基本结构:
     1>三种基本结构:
      1)顺序结构:程序的基本结构,它是按照书写顺序依次执行操作.
        输入三角形边长,求面积(s=1/2(a+b+c),   area=√s*(s-a)*(s-b)*(s-c))  sqrt(√)  )
        #include<math.h>
        #include<stdio.h>
        void main(){
          float a,b,c,s,area;
          scanf(“%f,%f,%f”,&a,&b,&c);
          s=1.0/2*(a+b+c);
          area=sqrt(s*(s-a)*(s-b)*(s-c));
          printf(“a=%7.2f,b=%7.2f,c=%7.2f,s=%7.2f\n”,a,b,c,s);
          printf(“area=%7.2f\n”area);
        }
      2)选择结构:分支结构,是根据某个或某些条件,从若干操作中选择某个操作执行的一种控制结构.
        具体的,选择结构分为单分支选择结构,双分支选择结构和多分支选择结构三种;
    
      3)循环结构是由控制条件控制循环体是否重复执行的一种控制结构.
        循环结构分为当型循环结构,直到型循环结构和次数型循环结构三种;
      
     2>九种控制语句
      1) if(){}else{} (条件语句)
      2) for()
      3) while()
      4) do~while()(循环语句 3)
      5) continue (结束本次循环语句)
      6) switch(多分支选择语句)
      7) break(终止switch或循环语句)
      8) goto(转向语句)
      9) return(从函数返回语句)
    
    3.函数调用语句
      格式 :函数名(参数1,参数2,…参数n),
      功能 :调用指定的库函数或用户自定义函数,对圆括号中的参数进行该函数指定的运算,运算结果作为函数的返回值返回;
            本质上,函数调用语句是函数调用后面跟一个分号.  例:c=max(a,b);
    
    4.表达式语句 int a=2; int b=a+2; (a>b)? a:b;
    
    5.复合语句:if(){}else if(){}else{};大括号(“{}”)中的语句不会因为”;”结束,括号内的语句都会被执行
     1>字符输出函数putchar(ch)
      1)[调用格式]putchar(ch)使用它,必须在C源程序的开头加上编译预处理命令#include<stdio.h>或#include"stdio.h";
        "ch"可以是一个整型变量,字符型变量,整型常量或字符型常量,也可以是转义字符或整型表达式,但不能是字符串;
      2)[功能] 把一个字符输出到标准输出设备(显示器).此外,就功能而言它可以被”%c”格式说明符的printf()函数完全替代;
      3)[返回值] 输出ch对应的单个字符; 一次输出一个字符
    
     2>字符输出函数getchar()
      1)[调用格式] getchar()  使用它,必须在C源程序的开头加上编译预处理命令#include<stdio.h>或#include”stdio.h”;
      2)[功能] 从标准输入设备(键盘).输入一个字符,就功能而言它可以被”%c”格式说明符的scanf()函数完全替代;
      3)[返回值] 输出的单个字符
    
     3>printf(格式控制,输出表列)
      %d—以有符号的十进制整数形式输出(正整数不输出”+”)
      %o—以八进制无符号形式输出整型数据(不能输出前缀0)
      %X/x—以十六进制无符号形式输出整型数据(不输出前缀0x)
      %u –以十进制无符号形式输出整型数据
      %f –以小数形式,小数部分为6位  %m.nf  占m宽,保留n位小数
      %c -- 以字符形式输出
      %s -- 以字符串形式输出
    
    第五章:数组
    1.定义:数组是具有相同数据类型的一组有序数据的集合.
      1>数组中的数据称为数组元素,数组元素通过数组名和下标引用,下标是数组元素在数组中的位置序号,
        表示该数组元素在数组中的相对位置;(下标从0开始)
    
      2>声明 数组类型  数组名[常量表达式]  int a[6]  数组名表示内存首地址,是地址常量;
    
      3>一维数组元素的引用表示方法数组名[下标]
     
    2.二维数组
     1>声明: 数据类型符 数组名[行长度][列长度],…;
      *1.数据类型可以是任何基本类型.
      *2.数组名和变量名一样,必须遵守标识符的命名规则.
      *3.行长度说明二维数组有几行,列长度说明二维数组有几列;行长度和列长度都是一个整型常量表达式,表达式中不能出现变量;
      *4.二维数组的元素个数=行长度*列长度;
         int a[2][3]={{1,2,3},{4,5,6}}  3行,4列  a[0][0],a[0][1],a[0][2], ,a[1][0]….
         Int b[][3]={1,2,3,4,5};--intb[2][3]={{1,2,3},{4,5,0}};(没有赋值的默认为0(int的默认值))
      *5.二维数组元素在内存中的排列顺序是”按行存放”,即先顺序存放第一行的各个元素,再存放第二行的各个元素,以此类推;
      *6.可以把二维数组看做是一种特殊的一维数组,,其每个元素都是一个一维数组;
      *7.一个数组定义语句中可以只定义一个二维数组,也可以定义多个二维数组,可以在一条定义语句中同时定义一维和二维数组,
         同时还可以定义变量;
      *8.二维数组的行列元素互换a[j][i]=b[i][j]    int a[2][3]={{1,2,3},{4,5,6}}; int b[3][2]={{1,2},{3,4},{5,6}};
    
    3.字符数组
     1>gets(字符数组) 输入字符串
       char a1[15]; gets(a1)  在scanf(“%s”,a1)中遇空格(\n)字符串便结束了,而gets()中,将空格作为字符存入字符型数组中;
    
     2>puts(字符数组)->输出字符串
     3>字符串比较函数strcmp
         *1.格式:strcmp(str1,str2);
         *2.功能:比较两个字符串;
         *3.比较规则:对两个串从左到右逐个字符比较(ASCII码),直到遇到不同字符或’\0’为止.
    	*4.返回值:返回int型整数,其值是ASCII码的差值
     			a.若str1<str2,返回负整数;  b. 若str1>str2,返回正整数; c. 若str1==str2,返回0;
    	*字符串比较不能用”==”,必须用strcmp(str1,str2);
    
     4>strcpy(字符数组名,字符串[,整型表达式])(复制字符串)
       将字符串赋值给字符数组(字符数组名,且字符数组的长度必须>字符串的长度);
    
     5>strcat(字符数组名,字符串)(连接字符串)
       将字符串连接到字符数组中字符串的尾端(最后一个有效字符的后面)
     6>strlen(字符串)字符串长度,不包含’\0’ ;
     7>strlwr(字符串) 将字符串中的大写写字母转换成小写字符串
     8>strupr(字符串)将字符串中的小写字母转换成大写字母(-32)65~97
      
    第六章函数
     1.函数之间,没有从属关系,互相独立,不能嵌套定义,有且只有一个main函数,且结束和开始都是main函数;
     2.分为库函数和用户函数、有参函数和无参函数、有返回值和无返回值函数;
     3.格式:函数首部+函数体:
       数据类型(无:void) 函数名(形式参数表)  函数首部{
              函数体
            数据定义语句部分;
            执行语句部分;
        }
    
     形参:定义函数时函数名后面括号中的变量名,  实参:调用函数时函数名括号中的表达式;max(a,b)->实参,
          void max(int x,int y)->形参;
     
     用户函数如果在main()之前可以不做函数声明,但如果在main()下面的话就要在main()中声明函数, 数据类型 函数名(参数列表)
    
     4.变量的存储类型
       C语言中变量的存储类型为自动性(auto),寄存器型(register)(定义局部变量),外部型(extren)和静态型(static);
       变量的存储方式分为静态存储方式和动态存储方式两大类.(静态,每次改变会保留,动态不会保留,用完释放)
       自动型和寄存器型变量属于动态存储方式 ;
       外部型变量和静态型变量属于静态存储方式 ;
    
    第七章 指针
     1.定义:C语言中的指针是一种数据类型(X86占4字节,X64占8字节)
       *1.它与其他变量的不同就在于它的值是一个内存地址,
       *2.变量&&地址&&内存宽度; 指针指定了内存地址和内存宽度(由指针类型决定(int 内存宽度就是4字节))
       指针-->内存地址+内存宽度; 例 .i 地址 0x108 ,int i=10; int *p=&i;-->p(0x108) ;
       printf(“p:%p,&i:%p,sizeof(p):%d\n”,p,&i,sizeof(p));
    
      1>计算机系统的内存拥有大量的存储单元(每个存储单元的大小为1字节),为了便于管理,
        必须为每个存储单元编号,该编号就是存储单元的"地址",每个存储单元拥有一个唯一的地址.
    
      2>指针变量除了可以存放变量的地址外,还可以存放其他数据的地址,例如可以存放数组和函数的地址.
    
      3>指针变量:int *p; int a;   p=&a(将a的地址给指针p,p存储a地址的首地址);
    
      4>指针变量定义的一般形式:
    
       *1.[格式] 数据类型符 *指针变量名[=初始地址值],...;
    
        ①.声名:数据类型 *变量名 (int *p) ;  int b[6]; int *p[];
    
        ②.赋值 p=&a --[a为int型变量]   p=b;
    
        ③.使用:*p就是取被存储地址的内容,也就是*p==a;
    
       *2.[功能]定义指向"数据类型符"的变量或数组的指针变量,同时为其赋初值;
    
       *3.注意事项
    
        ①."*"表示定义的是一个指针变量,指针变量的前面必须由"*"号.
    
        ②.在定义指针变量的同时也可以定义普通变量或数组等;
    
        ③."数据类型符"是指针变量所指向变量的数据类型,可以是任何基本数据类型,也可以是其他数据类型;
    
        ④."初始地址值" 通常是"&变量名" "&数组元素" 或"一维数组名",这里的变量或数组必须是已定义的.
    
        ⑤.在定义指针变量时,可以只给部分指针变量赋初值.
    
        ⑥.指针变量的初始化,除了可以是已定义变量的地址,也可以是已初始化的同类型的指针变量,也可以是NULL(空指针);
    
        ⑦.指针变量初始化时,指针变量的"数据类型符" 必须与其"初始地址值"中保存的数据的类型相同;
    
    2.指针变量的初始化
     1>一般形式:[存储类型] 数据类型 *指针名=初始化地址;
       例 int I;  int *p=&i; int *q=p;  不能用auto变量的地址去初始化static型指针;
       &取地址运算符,它是单目运算符,取地址运算符的运算对象必须是已定义的变量或数组元素,但不能是数组名,
       运算结果是运算对象的地址;
       int a[10];  *a=a[0]  数组名就是数组的首地址;  &是获取变量的地址, *是取指针的内容是什么;
    
     2>取地址符(&) 的结合性是从右往左; int a; int *p=&a; ++p;是向下在走一个地址;
       “&”(reference)取引用地址, “*”(dereference)解析引用地址的值;
    
     3>解引用运算符(“*”)
       “*”解引用运算符(通过指针找到对应内存和里面存放的数据类)
       *p1==>就是p1(内存地址)中的值,(取内存地址中的内容) *p改变也就是指针p对应内存地址中的值改变了.
       那该内存对应的变量值也改变了;
       例.int a,*p; a=10; p=&a;-->*p==10  ,if(*p+1)-->a=11|if(*p-1)-->a=9;
       指针p指向内存地址的首地址基本类型就是变量a的地址->&a;
       对指针指向地址内容的修改:
       *1.“*”解引用运算符作用的指针p指向的内存地址不能是NULL(*void)或野指针;
       *2.char *s=”Hello World” *s=“X”(error) 因为字符串存储在静态常量区,不能被修改;
       *3.对*p的运算操作-->就是对指针p所指向的内存地址中的内容进行运算操作;
          -->也就是改变了所有引用该内存地址变量的值;
       *4.*&a==a;
        void func(char *p)//此处*p是定义指针(形参是指针变量){
          Printf(“%c\n”,*p);//取值(取指针p所指向的内存地址的值);
        }
    
     4>指针的赋值和使用
       char i,j,*p1,*p2;
       i='a';j='b';p1=&i; p2=&j; *p1=*p2;(地址没变,只是值一样了),
       p1=p2-->p2=>P1(p2的地址赋给p1) p2和p1都指向同一个内存地址;
    
     5>指针类型的互相转换
       int *p1=&a; char *p2=(char*)p1
       p1和p2的长度(内存宽度不同p1是4个字节宽度,p2的内存宽度是1个字节)不同,可访问的宽度也不同;
       void*p指针没有内存宽度;(优点可以接收任何类型的指针的赋值)
    
     6>sizeof(p)-->指针的长度(x86 4byte, x64 8byte), sizeof(*p):指针对应类型的长度;
    
     7>指针的加减运算(只支持加减运算)
       对于指针p,指针的加法运算p=p+n(或者p+=n)中,p向前移动的距离不是n个字节,
       而是n个指针的单位长度,即n*sizeof(*p)个字节,减法反之;
       二级指针: int a=10; int *p=&a; int**pp=&p ;    pp-->p--a    指针作为实参时,必须传二级指针;
    
     8>指针和数组
       数组的指针是指向数组在内存的起始地址,数组元素的指针是指向数组元素在内存的起始地址
       若将指针变量指向一维数组,可以采用以下两种方法:
       *1.在数据定义语句中用赋初值的方式,即*指针变量=数组名
       *2.在程序中用赋值的方式,即指针变量=数组名;
    
    第八章 内存管理
    1.系统虚拟内存空间布局
      1)2GB内核空间
      2)64kB非法区域
      3)进程空间
      4)64KB NULL空间
    
    2.内存分类(由低到高)
      1)栈及增长方向(Stack)
      2)空闲区
      3)堆(非连续区域)(heap)
      4)代码(code)区
      5)静态区(.data/.bss/.rdata);
    
    3.堆和栈的区别
     1>内存分配:
       栈:由系统自动分配与回收,int b=0;增长有高到低,声名和释放有系统管理;
       堆:malloc/free,地址由低到高;声名要调用malloc函数,释放要调用free函数;
    
     2>大小限制
       栈:应用层1M到10M,内核层:12K到24K不等
       堆:受限于计算机系统中有效的虚拟内存;
    
     3>效率比较
       栈:由系统自动分配,速度较快,但程序员是无法控制;
       堆:速度比较慢,而且容易产生内存存片;(容易产生内存泄漏);
    
     4>存放内容
       栈:用以记录程序执行时函数调用过程中的活动记录(栈帧),参数,返回地址,ebp,局部变量等;
       堆:一般是在堆的头部用一个字节存放堆的大小,剩余部分存储的内容由程序员根据程序计算的需要决定;
    
    4.内存地址的分类
     1)逻辑地址:段地址+段内偏移组成
     2)线性地址:由逻辑地址转换而来;
     3)物理地址:CPU放出的电平讯号;
    
    5.内存的寻址模式
     1)分段模型 在16位系统中 16位寄存器存储不够,需要用两个完成,需要偏移地址(造成分段)  seg<<4(对应16)+Offset
     2)扁平模型 在32位中寄存器也是32位,不用再分段
     3)实模式(对应分段模型)
     4)保护模式(对应扁平模型)
    
    
    6.内存分配
     1)静态区-->全局基本类型变量
     2)栈--->局部变量
     3)堆-->char *p=(char *)malloc(256); //分配256个字节内存
       If(p==NULL)return
       free(p)释放内存 调用malloc需要用头文件 #include <malloc.h>
     4)内存泄漏
    
    
    
    展开全文
  • 一、程序设计基础1、Python历史2、Python特点Python的伪代码(形式语言)更接近于自然语言(自然语言)胶水语言3、Python的应用:Google、Youtube等4、IDE1)Python是解释性语言(“同声传译”),支持有两种方法使用解释器...

    一、程序设计基础

    1、Python历史

    2、Python特点

    Python的伪代码(形式语言)更接近于自然语言(自然语言)

    胶水语言

    3、Python的应用:Google、Youtube等

    4、IDE

    1)Python是解释性语言(“同声传译”),支持有两种方法使用解释器:交互式模式(interactive

    mode)和脚本模式(script mode)。

    (1)交互模式:退出exit()

    (2)脚本模式:

    三种代码格式:源代码py 字节代码pyc 优化代码pyo

    代码注释行用#符号开始(用法同C++的//)

    注释块:两个三双引号(""")内的代码

    2)Spyder集成编程环境

    5、基本输入输出语句

    ①屏幕行输出函数:

    print

    (,,...),Python2不需要括号。输出占一行。

    print后面参数以逗号结尾,则输出变量值后不换行

    print后面无参数,则输出一空行。

    ②键盘输入函数:

    Python2和3中input(['']),接收键盘输入,并返回表达式;

    Python2中raw_input

    (['']),返回值是键盘输入的字符串(若用为数字则需强制类型转换);

    input()等价于eval_r(raw_input())。

    Python可以一边输入一边赋值。如

    num1=int(raw_input())

    二、常量变量

    1、和C语言相似的转义字符

    \n换行newline \'单引号

    2、变量名是大小写敏感的,变量名的命名原则也符合一般的标示符规则;变量在使用前必须已经定义(先定义再使用)

    Python的变量赋值(变量绑定对象),实际上是将值指向址,同一个值指向同一个址,而址可以映射不同的变量名。这是与其他语言区别的地方

    三、数据类型

    1、数据类型函数:type()

    整数(integer):十进制21 八进制025

    十六进制0x15

    浮点数(float):1.65 2. .21 2.1E2

    布尔数(boolean):布尔值(True False),注意大小写

    复数(complex):1+2i

    字符串(string):使用单引号、双引号或三引号括起来。三引号(''')括起来时,保留了字符串中的全部信息,包括回车。

    2、Python并不需要使用变量前先要类型声明,但在使用前还是需要先初始化赋值

    3、类型转换

    和C一样,计算中也有自动类型转换:bool→int→float→complex

    Python也支持强制类型转换: (),如int

    ('32'),int(3.9)等(类型转化的类型名不用加小括号,这与C不同)

    四、运算符(按运算符优先级排列;除特别声明多为左结合性)

    1、算术运算符:

    **(乘方,即指数运算,右结合性,如2**2**3==256,而不是64)

    *

    /(除,除不尽结果用double型输出)

    %取余 #(3.0以上版本,除,结果向下取整floor division)

    + -

    加减乘除甚至可以用于字符串运算(级联),例如:'very'+'good'、'repeap'*3等

    2、关系运算符

    ①>大于 =大于等于 <=小于等于

    ==等于 !=(或<>)不等于

    ②Python与C不一样的是,它可以这样写一个关系表达式1 < a

    < 2

    3、逻辑运算符

    ①not逻辑否 and逻辑与 or逻辑或

    ②逻辑运算的结果是逻辑常量True、False,但在表达式中所有非0数都被运算为True。有些与C不同的:

    123 and 456 --> 456

    123 or 456 -->123

    4、赋值运算符(右结合性)

    ①= *= /= += -= %= //=

    注意Python不支持C语言的自增自减

    ②Python支持这样的赋值写法:

    a,b=1,2

    a,b,c=eval_r(raw_input("输入三个数")) #eval用于转换字符为表达式

    五、表达式

    Python表达式和语句不同,表达式具有一个值,语句没有。

    a+1是表达式

    a=1是语句

    六、控制结构流程图

    一)顺序

    二)分支

    1、if :

    elif :

    else:

    (和C语言不同的是)if、elif、else后面的表达式不用小括号括起来,表达式后面的语句组也不需要用大括号{}括起来(用强制缩进表示程序块),这意味着Python是以一行表示一个语句的(一行上语句过长,可用_续行);若if体中暂没有语句,可用pass占位;语句体只有一句,则可以喝if、elif或else合并为一行

    if、elif、else按序检查,若满足其中一个条件,就执行,之后的就跳出if体。

    2、条件赋值

    =a,if else b

    条件成立时,变量值为a,否则为b

    三)循环

    循环,一般由循环初始值、循环条件、循环动作、更新循环条件等组成

    1、while循环和for循环(和C不同)

    ①while :

    else:

    ②for in

    range([,][,]):

    else:

    for用于已知次数的循环

    2、for和while的转换

    for和while还是有一些区别的,for是遍历数组值,while则是逻辑值

    错在哪里?

    右边的while循环,i的终值被多加了1个步长

    3、循环控制(和C相同)

    break跳出当前循环

    continue跳出当次循环

    七、函数

    一)内置函数——模块

    import

    math这样的语句用于导入模块(类似C中的头文件、库文件)

    ●模块中有哪些对象方法属性,可用dir函数,dir

    ()

    ●模块的使用,类似于对象的属性、方法的调用(即“点记法”),如math.pi、math.sin()、math.log10()

    ●此外,还可以用from import

    *,来导入模块中所有的对象,在使用时就可以直接使用,不需加和点

    import math.tan [as

    tg]则引入math中的tan,[并重命名为tg]

    二)自定义函数

    def ( )

    返回值return 。

    函数可以有1个或更多个形参,也可以无形参(但括号不能省);形参的作用域为local,可以用global来声明全局变量。

    与C不同的一些地方:

    ①函数在使用前必须已经定义,但在使用前无需像有些高级语言那样声明

    ②参数指定

    关键字赋值:在调用时指出,这样引用时就不受形参位置的影响

    函数体内定义另一个函数,并调用。例如定义了一个函数f(big,small),调用时可以这样引用f(small=1,big=3)

    缺省参数:

    三)递归

    一个函数使用时可以调用另一个函数,同样一个函数也可以调用它自己,这就是“递归”。

    生活中的递归如老和尚讲故事、德罗斯特效应、两面相对的镜子等;数学上可以用递归编程的有阶乘、斐波那契数列、汉诺塔等。

    一个递归函数一般由递归条件(“递”)和递归出口(“归”)构成;递归编程的口诀“掐头去尾留中间”

    八、算法

    九、数据结构

    I、字符串String

    一)字符串函数

    长度:len()

    拼接: +

    重复: *n

    成员运算符(是否包含,返回True、False): in

    遍历: for c in :

    二)字符数组的概念和使用

    1、

    []

    方括号[ ]就是索引运算符

    索引号从0开始(整数第一个字符),负索引号从-1开始,即从字符串倒数第一个

    2、切片:使用冒号可以引用索引号前后之间的字符串

    [start:finish],start:子序列开始位置的索引值 finish:子序列结束位置的下一个字符的索引值

    [start:finish:countBy] 间隔切片,countBy缺省为1

    my_str='hello world'

    my_str[0:11:2]

    -->'hlowrd'

    countBy为-1时可获得逆字符串

    my_str='world'

    my_str[::-1]

    -->'dlrow' #my_str==my_str[::-1]用于判断单词是否回文

    3、不能用字符串索引来改变字符串的值

    my_str='hello world'

    my_str[1]='l' #错误

    但可以使用切片、拼接等方式,如

    my_str=my_str[:1]+'a'+str[2:]

    三)字符串方法

    替换:replace(old,new)

    my_str='hello'

    my_str.replace('e','a')

    -->'hallo'

    注意replace方法并没有改变字符串的值,只是输出一个替换的字符串,原字符串还是'hello'

    可以用dir(str)查看字符串的更多属性方法

    四)字符串比较

    可以对两个字符串关系运算,比较ASCII顺序

    五)字符串格式化与正则表达式

    II、文件File

    一)文件打开和关闭

    f=open('')

    f.close

    二)遍历文件行

    f=open('names.txt')

    for line in f:

    f.close

    III、列表List

    一)=[,,...] ,列表有点像数组,但列表中的元素可以是不同类型的。

    和字符串一样,可以通过下标、索引、切片等来引用列表元素,用法也相似,同样支持长度、拼接、重复、成员运算等。但和字符串不同的,列表及其元素是可以改变的。

    二)列表内建方法

    .append #在列表末尾追加一个元素,相当于列表做加法(+)

    .expend([]) #在列表末尾追加一个列表

    .insert(,)

    .pop() #从后删除一个元素

    .remove() #删除指定元素值

    .sort() #元素排序

    .reverse(() #元素逆序

    .swap(,,) #交换元素

    三)遍历算平均

    for num in :

    s+=num

    avg=s/len()

    四)列表内建函数

    sum() #求数值列表的和

    max

    min

    五)查找和排序

    1、线性查找

    .index() #线性查找元素第一次在列表中出现的位置,若找到返回该值的索引号,反之返回出错信息

    线性查找的时间复杂度为O(n)

    .find() #类似index,但不同的是找不到子字串时返回-1

    2、二分查找

    二分查找要先排序

    二分查找的时间复杂度为O(log2n)

    3、选择排序

    即每次遍历将最小值剪切到前面(或将最小值与初始最前面元素交换)

    选择排序时间复杂度为O(n2)

    4、冒泡排序

    每一次遍历都将小值排前,大值排后,循环一次以后,最大的元素被“沉底”;

    这样的循环遍历直到遍历时找不到小值在后的元素(即lst(i)>lst(i+1)始终不成立。

    冒泡排序的时间复杂度也是O(n2) ,但实际运行时冒泡法往往比选择排序时间少,因为冒泡排序法通常执行的比较操作更少

    5、使用内建的排序函数和方法

    sorted() 和 .sort() #返回一个拍好序(默认升序)的列表(源列表不变)。它使用了快速排序算法(quicksort),其时间复杂度O(nlogn)

    内建排序后面省略了两个参数(key=,reverse=),reverse的缺省值即False

    六)嵌套列表(二维列表)

    列表 lst = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

    这是一个三行四列的嵌套列表

    若访问第三行、第二列lst [2][1]

    len(lst)的结果是3(“行数”),不是12(总元素个数)

    那么如何知道列表的列数呢?len(lst[0])、len(lst[1])、len(lst[2])均可

    七)列表推导

    lst=[x**2 for x in range(1,10)]

    IV、元组Tuple

    相当于不可变的列表,用小括号来建立元祖

    可以使用索引、切片、len、print、index等方法;不可以使用append、extend、del等

    V、字典Dict

    1、用大括号来建立字典,字典元素由不可重复的键和值构成;键必须是不可变的且不重复(如整型、浮点型、元祖等不可变类型),值可以是任意类型(如列表等也可以)

    my_dict{'Tom':78,'Jim':89,'Mary':80}

    2、字典元素存储时并不按输入先后顺序排列,也不按字母顺序排列,所以字典不支持排序。因此,引用字典时应使用键名引用: my_dict['Jerry']=99

    3、字典也支持长度函数len、成员运算符in(判断一个“键”是否在字典中,它的时间复杂度为O(1),相比较字符串和列表的O(n),速度更快)等,此外字典还支持以下方法

    .items() #获取全部的键-值对

    .keys() #获取全部的键

    .values() #获取全部的值

    .clear() #清空字典

    VI、集合Set

    1、无序不重复元素(键)值。相当于没有值只有键的字典(所以也可以用{

    }建立集合,集合的元素类似于字典的键,其类型应是不可变不重复的,如整型、浮点型、元祖等);和字典一样,集合也没有顺序,不支持排序。

    2、集合的创建,使用set函数

    x=set()

    集合的添加add方法和删除remove方法

    x.add('body')

    x.remove('body')

    3、集合的运算符

    & 交集

    | 并集

    - 差集

    == 等于

    != 不等于

    in 成员

    for key

    in set 枚举

    VII、类和对象

    十、GUI简介

    GUI的第三方API库:TKinter、wxPython、PyQt、PyGtk等

    from Tkinter import

    * #导入GUI库

    def changeRelief( )

    root=Tk( ) #建立控件

    label1=Label(root,text="Hello")

    button1=Button(root,text="OK",command=changeRelief) #command=changeRelief事件处理绑定

    label.pack( )

    button1.pack( )

    root.mainloop( )

    十二、数据库

    数据库管理系统(DataBase Management System,DBMS)

    商业系统:Oracle、Microsoft SQL Server、IBM DB2等

    开源(Open Source)系统:MySQL、PostgreSQL、SQLite等

    其中,SQLite3版本的基本用法:

    1、安装:将zip解压即可

    2、创建或打开数据库

    sqlite3

    test.db

    3、创建一个表creat

    sqlite > creat table

    (name,num,phone)

    4、插入一行(记录)

    sqlite > insert into

    values('Zhang',1,'13150201234');

    5、查询

    select from

    select from where

    id=

    select from where id

    like

    6、删除delete

    delete from

    7、修改update

    update set Attribue=NEW

    8、在Python中使用SQLite3

    import sqlite3

    con=sqlite3.connect('test.db')

    cur=con.cursor() #创建一个游标

    cur.execute('select * from student')

    rows=cur.fetchall()

    for row in rows:

    print row

    十三、Web编程基础

    Django

    1、安装

    python setup.py install

    >djang-admin.py startproject mysite

    2、运行

    >python manage.py runserver

    3、创建应用

    python manage.py startapp addr_book

    编辑addr_book

    4、模板

    HTML语言

    模板不是必须的,可以将HTML代码写在视图中,但是这样不便于改动和分工(可以由专门的美工负责设计网页)。

    5、模型

    数据库

    HTML表单

    模型不是必须的,可以将数据库操作代码写在视图中,但是这样不便于切换到新的数据库,需要针对新的数据库修改代码。有了模型,切换数据库仅需要修改

    settings.py 即可。

    【相关网站】

    展开全文
  • 第一章 程序与程序设计 1. 程序是对解决某个问题的方法步骤的描述。 2. 从计算机角度来说,程序是用某种能理解并执行的计算机语言描述解决问题的方法步骤。 3. 二进制语言->汇编语言: 面向机器的语言...
  • 前言:JavaScript是一种非常松散的面向对象语言,一种全新的动态语言,致力于增强网站和web应用程序的交互性。 JavaScript历史回顾: 最早用来处理以前由服务器端语言负责的一些输入验证操作; JavaScript是一种专为...
  • 一、程序设计基础1、Python历史2、Python特点Python的伪代码(形式语言)更接近于自然语言(自然语言)胶水语言3、Python的应用:Google、Youtube等4、IDE1)Python是解释性语言(“同声传译”),支持有两种方法使用解释器...
  • 高级程序设计语言的一般特性3.1 高级语言的分类3.2 程序结构3.2.1 FORTRAN(第一个高级程序设计语言)3.2.2 PASCAL(结构化程序设计语言代表)3.2.3 Java(面向对象的高级语言)3.3 数据结构与操作3.3.1 数据类型...
  • 高级程序设计语言一、语言概述1.1 语法 v.s. 语义程序本质上是一定字符集上的字符串语法:一组规则,用它可以形成和产生一个合式(well-formed)的程序定义了程序的形式结构定义语法单位的意义属于语义问题语义:一...
  • 现在,我们己经知道了如何声明和初始化基本类型的变量,差不多可以准备编写程序了。在此之前,我们再了解一下如何进行计算以及将计算的结果保存起来。 考无忧小编推荐: 更多计算机等级考试真题及答案>>>点击查看 想...
  • 课程主要讲解了c++语言基础知识,以及类与对象高级应用。
  • 核心(ECMAScript) 提供核心语言功能 文档对象模型(DOM)提供访问和操作网页内容的方法和接口 浏览器对象模型(BOM)提供和浏览器交互的方法和接口 DOM级别 DOM1:映射文档结构 DOM2:引入DOM视图,DOM事件,DOM样式...
  • 课程主要讲解了c++语言基础知识,以及类与对象高级应用。
  • 课程主要讲解了c++语言基础知识,以及类与对象高级应用。
  •  javascript是一种专门为与网页设计交互也设计的脚本语言,ECMAScript、文档对象模型(DOM)、浏览器对象模型(BOM)这三种组成  ECMAScript是由ECMA-262定义,提供核心语言功能  文档对象模型(DOM)主要提供...
  • Javascript是一门专为网页交互而设计的脚本语言,由三部分组成: 1. ECMAScript, 由ECMA-262定义,提供核心语言功能。 2. 文档对象模型(DOM),提供访问和操作网页内容的方法和接口。 3. 浏览器对象模型(BOM)...
  • 闲下来的时间记录一下边读边做的笔记,大多是以前编程的时候没注意过的基础知识点。 第一章 JavaScript的完整实现包括以下三个部分: 1、核心(ECMAScript),提供核心语言功能。 2、文档对象模型(DOM),提供访问...
  • 文章目录高级程序设计语言一、语言概述1.1 语法 v.s. 语义1.2 作用域1.3 标识符 v.s. 名字1.4 左值与右值二、语法描述2.1 基本概念2.2 上下文无关文法2.3 推导2.3.1 基本概念2.3.2 语法树2.3.3 二义性2.4 形式语言...
  • 程序设计语言的基本成分包括 数据、运算、控制和传输等。 程序设计语言的控制成分包括 顺序、选择和循环3种结构。
  • 汇编语言程序设计学习笔记 第一章 1.1 汇编语言的一般概念 机器语言:二进制编码 效率高 不便记忆阅读 高级语言:方便 效率低 汇编语言 定义:为了便于记忆与阅读,使用字母和符号来表示机器语言的命令,用十进制数...
  • //defer属性会把脚本语言放到文本执行之后再执行 ,只有ie和fifox3.1支持 &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...
  • JavaScript高级程序设计学习笔记 1.对JavaScript实现各个组成部分的详尽解读 2.对JavaScript面向对象编程的全方位阐述 3.DOM,BOM及浏览器事件模型的透彻剖析 4.Web应用基本数据格式JSON,XML及存取 5.Ajax,Comet...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 968
精华内容 387
关键字:

高级语言程序设计笔记