基础 

语言分类 

编译型 :

    c,c++

     Java 有编译型,也有解释型

解释型:

    Python,Ruby,PHP

脚本语言特点:

需要解释器,

以文本形式存贮(程序代码->最终执行文件)

无类型, 动态语言

Python,Perl,JavaScript

高级语言翻译为机器语言的方式:

编译:

     程序执行前需要先编译, 以后运行不需要重新翻译如exe文件

解释:

    不需要编译,语句执行时翻译,需要解释器

    需要逐句翻译,执行效率低,每次执行需要翻译

运行Python:

     两种模式

          脚本式编程,  一次执行,源代码脚本

    命令行模式

          交互式编程, 逐行输入,再执行

运行代码脚本:

    命令行模式:python *.py

    Linux下执行脚本

    需要在env路径自动寻找解释器,

    脚本首行添加#!/usr/bin/env python(python路径)

    命令行赋予权限  chmod 777 *.py

    执行脚本  *.py

     ipython

     %run *.py

语言特点:

    解释型脚本语言,内建高级数据结构

    OOP, 数据和逻辑相分离

    动态语言, 变量本身,类型不固定,可随意转换

    不用考虑内存问题

    默认编码 UTF-8

基本规划

     注释 #

    \n 行分割符

    \ 继续上一行用于跨行

    闭合操作符,[], {}, (),

    多行注释 """ """, ''' '''

    ; 在同一行,连续多个语句

    : 分开代码块(组), 头&体

缩进块

    语句[代码块], 用缩进深度区分(一般4个空格)

空行

    用于分割 函数与类(便于维护和重构)

模块

     每一个脚本文件 均为模块,

     以磁盘文件的形式存在

     模块过大应该拆分代码,另建模块

变量赋值

    赋值符 =

    增量赋值 +=

     多重赋值 同一个引用被赋值给x,y,z.x = y = z = 1

     多元赋值

      x,y,z = 1,2,'a'

     = 两边都是元组,通常元组需要小括号,此处可省略,

     建议加上,可读性更高

     (x,y,z) = (1,2,'a')

     变量交换

     x,y=y,x

Python对象

    Python 使用对象模型, 来存储数据

特性

    身份: 唯一Id, id(),可用来判读是否为同一对象引用

    类型 type(),  值, 不可变对象, 调用自身任意方法

    不可变 对象自身内容, 总是 创建新对象后返回

    编写程序时,尽量设计成不可变对象

对象属性

     访问  句点(.)

     常用 属性,方法

动态类型

      特殊对象

      用于存储数据

      存储在内存

      无法直接接触

      对象名 指向这一对象的引用

核心思想

     引用和对象分离

     引用 可以随时指向,一个新的对象

     多个引用指向同一个对象

     如果一个引用值发生变化,不影响其他引用的指向,这个引用指向一个新的引用

对象类型

     可变数据对象

     通过引用其元素, 改变对象自身

     本质是包含了多个引用的对象

     每个引用指向一个对象

     如S1[0]=10,不是改变S1指向,而是对S1[0]进行操作,所有指向它的引用都受到影响

     list,set,dict

     不可变数据类型,   不能改变对象本身,只能改变引用指向

     如 str,num,tuple

函数的参数转递

     不同类型参数传递,     不可变数据对象,     不会影响原对象,     参数 新的引用,

     可变数据对象, 可能改变原对象,尽量避免用作参数,本质上传递的是引用

内存管理

     变量,变量在内存中的表示,

     1, a = 'ABC'

      步骤1,在内存中创建一个'ABC'的字符串

      步骤2,在内存中创建一个名为a的变量

     并把它指向'ABC'

      2, b = a

       步骤1,创建一个名为b的变量

        步骤2,把它指向a 指向的字符串'ABC'

     3, a = 'XYZ'

        创建一个'XYZ'的字符串, 把a指向改为 'XYZ'

        b的指向没有更改

        print b  -->'ABC'

本质上, 变量用来指向数据对象

      计算机内部把任何数据都看出一个[对象]

      对变量赋值会关联数据对象和变量,

常量, 全部大写的变量名,本质上还是变量

     删除对象的一个引用 del语句

     IO编程

     print()

     调试输出到控制台, 依次打印,遇到','输出空格

     print('a','b') --> a b

     input()

      读取键盘输入,可以接收 Python表达式并返回运行结果

  模块结构和布局

       起始行, 类Unix下使用

         可直接指向脚本, 无需调用解释器

   模块文档

       简要介绍 模块功能&重要全局变量

       访问方法  module.__doc__

       模块导入 导入[主程序]需要的模块

  变量定义

      全局变量 本模块可直接使用的变量

      类定义

      class.__doc__

      函数定义

     访问:module.function()

函数的文档变量:function.__doc__

主程序

      Python库风格

      仅一个模块(主程序模块),直接执行

     其他大多是模块,       创建目的 被调用, 而不是独立执行

NODE:

        尽可能少顶级代码

        函数或泪中,尽量封装到功能代码

        通常只有主程序模块,有大量顶级代码

__name__

被导入, __main__ __name__的值直接执行

运算符

 算术运算符

+ 加 - 两个对象相加 a + b 输出结果 31

- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11

* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210

/ 除 - x 除以 y b / a 输出结果 2.1

% 取模 - 返回除法的余数 b % a 输出结果 1

** 幂 - 返回x的y次幂 a**b 为10的21次方

// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

 比较运算符

== 等于 - 比较对象是否相等 (a == b) 返回 False。

!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。

> 大于 - 返回x是否大于y (a > b) 返回 False。

< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。

>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。

<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

赋值运算符

= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c

+= 加法赋值运算符 c += a 等效于 c = c + a

-= 减法赋值运算符 c -= a 等效于 c = c - a

*= 乘法赋值运算符 c *= a 等效于 c = c * a

/= 除法赋值运算符 c /= a 等效于 c = c / a

%= 取模赋值运算符 c %= a 等效于 c = c % a

**= 幂赋值运算符 c **= a 等效于 c = c ** a

//= 取整除赋值运算符 c //= a 等效于 c = c // a

位运算符

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

(a & b) 输出结果 12 ，二进制解释： 0000 1100

| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

(a | b) 输出结果 61 ，二进制解释： 0011 1101

^ 按位异或运算符：当两对应的二进位相异时，结果为1

(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。

~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。

<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。     a << 2 输出结果 240 ，二进制解释： 1111 0000

>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符

and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

(a and b) 返回 20。

or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

(a or b) 返回 10。

not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

not(a and b) 返回 False

成员运算符

in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

运算符优先级

** 指数 (最高优先级)

~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % // 乘，除，取模和取整除

+ - 加法减法

>> << 右移，左移运算符

& 位 'AND'

^ | 位运算符

<= < > >= 比较运算符

<> == != 等于运算符

= %= /= //= -= += *= **= 赋值运算符

is is not 身份运算符

in not in 成员运算符

not or and 逻辑运算符

运算符重载

class A:

     def __init__(self,a,b):

         self.a = aself.b = b

    def __str__(self):

         return 'A (%d,%d)' %(self.a, self.b)

    def __add__(self,other):

          return A(self.a + other.a, self.b + other.b)

v1 = A(5, 15)

v2 = A(6, -3)

print v1 + v2

输出:  A (11,12)