Python 语法

///////////////////////////////////////////////////
//
// Python 语法
//
////////////////////////////////////////////////////

一、Python 基本知识
【特点】
1. 跨平台
2. 面向对象
3. 像胶水，可以连接两个语言编程
4. 编程简单

【基本】
    1. 脚本解释说明
        #!/usr/bin/python   //在 unix/linux 下 才会有这句，windows下没有
    2. 编码方式说明
        # -*- coding: UTF-8 -*-     // 设置编码方式，否则会影响代码解释，输出
    3. 严格行和缩进
        1)不是用{} 等来控制，就意味着要严格控制行和缩进
        2)可用;显示多条语句(一般不这么做)
    4. 多行语句
        当一行语句写不完 可用 "" 进行折行
【注释】
    1. 单行注释
        在单行代码行首 加 "#"
    2. 多行注释
        用一对三引号''' 或 """ 来包裹多行要注释的代码

二、Python 基本语法
【输入、输出】
键盘输入、屏幕输出.
1. 输入：
a. 数字型等
var = input()
b. 字符串型
var = raw_input() （python3 已舍弃）
返回一个字符串
2. 输出：
a. print
1)利用print + var1,var2,... 输出var （python3中已舍弃）
2)利用print(var) ，输出var
3) end关键字，可以不换行打印
关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符
a,b = 0,1
while b < 1000:
print(b,end=‘,‘)
a,b = b,a+b
b. write
利用sys模块中stdout对象之write(var),输出var
【变量】
1. 创建变量
var1,var2 = 初始值1,初始值2 #分别对var1，var2 进行初始化。

2. 删除变量
        del 变量1，变量2
【数据类型】
    1. Numbers（数字）
        a. int（有符号整型）
        b. long（长整型[也可以代表八进制和十六进制]）常用大写L表示   [Python3 中舍弃]
        c. float（浮点型）
        d. complex（复数）
            利用a+bj 表示，a 和 b 属于浮点型(数字型)，j为复数常量
    2. String（字符串）
        a. 单引号  成对
            表示存粹的字符串，一切皆为字符串。
        b. 双引号 成对
            可以转义字符等。
        c. 三引号 成对
        
        d. Unicode 字符串
            在普通字符串前面加上u
    3. List（列表）
        list = [element1,element2,...]
        相当于C语言中数组   
        
        特点：
            可修改元素的值。
        访问：
            列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，
            从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
            
            list[index]
        列表推导式
            vec = [2,4,6]
            >>> [3*x for x in vec]
            [6,12,18]
    4. Tuple（元组）
        tuple = (element1,...)
        
        特点：
            一旦创建，不能修改 元素的值。
        访问：
            类似List(列表)
    5. Dictionary（字典）
        dict = {'key1':value1,'key2':value2,...)
        
        特点：
            可修改 键、值
        访问：
            dict[key]
    
    6. Set(集合) [Python3 数据类型]
    
        集合（set）是一个无序的不重复元素序列。
        创建：
            parame = {value01,value02,...}
            或者
            set(value)
        注：
            isinstance 和 type 的区别在于：
                type()不会认为子类是一种父类类型。
                isinstance()会认为子类是一种父类类型。
    
        不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
        可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
    7. 类型转换
        int(x [,base])
            将x转换为一个整数
        long(x [,base] )
            将x转换为一个长整数
        float(x)
            将x转换到一个浮点数
        complex(real [,imag])
            创建一个复数
        str(x)
            将对象 x 转换为字符串
        repr(x)
            将对象 x 转换为表达式字符串
        eval(str)
            用来计算在字符串中的有效Python表达式,并返回一个对象
        tuple(s)
            将序列 s 转换为一个元组
        list(s)
            将序列 s 转换为一个列表
        set(s)
            转换为可变集合
        dict(d)
            创建一个字典。d 必须是一个序列 (key,value)元组。
        frozenset(s)
            转换为不可变集合
        chr(x)
            将一个整数转换为一个字符
        unichr(x)
            将一个整数转换为Unicode字符
        ord(x)
            将一个字符转换为它的整数值
        hex(x)
            将一个整数转换为一个十六进制字符串
        oct(x)
            将一个整数转换为一个八进制字符串
【迭代器 & 生成器】

    迭代器：
        迭代是Python最强大的功能之一，是访问集合元素的一种方式。
            iter(集合变量) 
            next(集合变量)
            ###########################
            >>> list=[1,2,3,4]
            >>> it = iter(list)    # 创建迭代器对象
            >>> print (next(it))   # 输出迭代器的下一个元素
            1
            >>> print (next(it))
            2
        创建一个迭代器：
            把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
    生成器：
        在 Python 中，使用了 yield 的函数被称为生成器（generator）。
【运算符】
    1. 算术运算符
        +
            相加
        -   
            相减
        *
            相乘
        /
            相除
        %
            取模
        **
            取幂值
        //
            取整除  (返回商的整数部分)
    2. 比较运算符
    
        比较返回布尔值 False,True.
        == 
            比较俩对象是否相等
        !=
            比较俩对象是否不相等
        <>
            比较俩对象是否不相等
        >
            大于
        <
            小于
        >=
            大于等于
        <=
            小于等于
    3. 赋值运算符
        =
            赋值
        +=
            加法赋值
        -=
            减法赋值
        *=
            乘法赋值
        /=
            除法赋值
        %=
            取模赋值
        **=
            幂赋值
        //=
            取整除赋值
    4. 位运算符
        *  
            按位与
        |
            按位或
        ^
            按位异或
        ~   
            按位取反 类似于 -(x+1)
        <<
            左移运算符
        >>  
            右移运算符
    5. 逻辑运算符
        and 
            两者都为真，结果才为真
        or
            一者为真，结果为真
        not
            一者为假，结果为假
    6. 成员运算符
        in  
            1) 如果在指定的序列中找到值返回 True，否则返回 False。  
            2) x 在 y 序列中,如果 x 在 y 序列中返回 True。
        not in  
            1) 如果在指定的序列中没有找到值返回 True，否则返回 False。
            2) x 不在 y 序列中,如果 x 不在 y 序列中返回 True。
    7. 身份运算符
        a. is  
            比较两者是否是引用自同一个对象
        b. is not
            比较两者是否是引用自不同一个对象
【条件】
    1. if 判断条件:  执行语句(或者换行)
    
    2. if 判断条件：
            执行语句……
        else：
            执行语句……
            
    3. if 判断条件1:
            执行语句1……
        elif 判断条件2:
            执行语句2……
        elif 判断条件3:
            执行语句3……
        else:
            执行语句4……
【循环】
    1. while 循环
        1) while 判断条件：
            执行语句……
        2) while 判断条件：
            执行语句……
           else:   
            执行语句……  # while循环条件不成立时的执行语句
    2. for 循环
        1) for 元素 in 集合:
                执行语句……
        2) for 元素 in 集合:
                执行语句……
           else:
                执行语句…… #条件不成立时，执行语句
    3. 循环控制语句
        1) break
            跳出循环，且只能跳出1层。
        2) continue
            跳过当前循环，继续循环下去
        3) pass
    注：
        1. while 和 for 循环之间是可以互相嵌套使用的。
        2. break 、continue 只用于for、while循环中
        3. pass 可以用于任意结构中，意为什么也不做。
【函数】
    1. 定义函数
        def 函数名(参数表)：
            执行语句
            return 返回值
        
        参数表:
            a. 可为数据类型
            b. 可用默认值，从右向左(一般)
            c. 不定长参数的函数定义
                def functionname([formal_args,] *var_args_tuple ):
                   "函数_文档字符串"
                   function_suite
                   return [expression]
                   
                注：
                    加了星号（*）的变量名会存放所有未命名的变量参数。
    2. 调用(使用)函数
        a = 函数名(参数表)
    3. 参数
        1) 不可更改
            a = 5
            a = 10 # 这里不是将a赋值为10，而是指向被new一个int 为10的数。
        2) 可更改
            而list、tuple、dictionary 是可更改的
    4. 匿名函数(lambda 表达式)
        lambda [arg1 [,arg2,.....argn]]:expression
            
【模块 & 包】
    搜索路径
        当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
            1、当前目录
            2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
            3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
        模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
    
    1. 模块
        描述:
            Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
        导入:
            描述:
                将该模块引用进来
            语法:
                a. import module1[,module2[,... moduleN]]
                    导入以上模块
                        如果有必要，也可以使用 [模块名.函数名] 来进行调用
                        
                        比如：
                            math.sin(30);
                b. from moduleName import name1[,name2[,... nameN]]
                    从模块中导入一个指定的部分到当前命名空间中
                c. from moduleName import *
                    把一个模块的所有内容全都导入到当前的命名空间
        dir(moduleName) 函数:
            dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
                返回的列表容纳了在一个模块里定义的所有模块，变量和函数
            
            特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。
            
        globals() 和 locals() 函数
            根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
            如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
            如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
            两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

        reload() 函数
            当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
            因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。
              语法如下：
                reload(module_name)
    2. 包
        包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
        简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件,该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。
        
        考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下：
            test.py
                package_runoob
                |-- __init__.py
                |-- runoob1.py
                |-- runoob2.py
                
        导入包：
            from package_runoob.runoob1 import runoob1
            from package_runoob.runoob2 import runoob2
            
            runoob1()
            runoob2()
    3. 内置模块
        数学模块
            1）math
                数学模块(常用)
            2）cmath
                复数模块
【异常处理】
    1. try....except...else
        try:
            <语句>        #运行别的代码
        except <名字>：
            <语句>        #如果在try部份引发了'name'异常
        except <名字>，<数据>:
            <语句>        #如果引发了'name'异常，获得附加的数据
        else:
            <语句>        #如果没有异常发生
    2. try-finally
        try:
            <语句>
        finally:
            <语句>    #退出try时总会执行
        raise
        
【面向对象】
    1. 类
        创建类:
            class ClassName:
               '类的帮助信息'   #类文档字符串
                class_suite  #类体
            
        注:
            类的帮助信息可以通过ClassName.__doc__查看。
            class_suite 由类成员，方法，数据属性组成。
            
        实例: 
            #!/usr/bin/python
            # -*- coding: UTF-8 -*-
             
            class Employee:
               '所有员工的基类'
               empCount = 0
             
               def __init__(self,name,salary): 
                  self.name = name
                  self.salary = salary
                  Employee.empCount += 1
               
               def displayCount(self):
                 print "Total Employee %d" % Employee.empCount
             
               def displayEmployee(self):
                  print "Name : ",self.name,",Salary: ",self.salary
            
            特殊方法
                1) __init__(self):  
                    __init__ 为构造函数，self 为实力本身
                2) __del__(self):
                    析构函数，
        你也可以使用以下函数的方式来访问属性：
            getattr(obj,name[,default]) : 访问对象的属性。
            hasattr(obj,name) : 检查是否存在一个属性。
            setattr(obj,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
            delattr(obj,name) : 删除属性。
        
        实例：
            hasattr(emp1,'age')    # 如果存在 'age' 属性返回 True。
            getattr(emp1,'age')    # 返回 'age' 属性的值
            setattr(emp1,'age',8) # 添加属性 'age' 值为 8
            delattr(emp1,'age')    # 删除属性 'age'
    2. Python内置类属性
        __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
        __doc__ :类的文档字符串
        __name__: 类名
        __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
        __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
    3. 类继承
        class 派生类名(基类名1,基类名2,...)
            ...
            
        你可以使用issubclass()或者isinstance()方法来检测。
            issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
            isinstance(obj,Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
        子类构造函数(方法)：
            子类若需要父类的构造方法需要          
            1) 显示调用父类方法   (重写,创建时完成多态)
                    super(子类，self).__init__(参数1,参数2,...)
                或
                    父类名称.__init__(self,参数1，参数2，...)
            2)  或者不写父类的构造方法
    4. 运算符重载
        __add__ 
        __str__
        __repr__
        __cmp__
            ...等 魔法方法
    5. 访问性
        默认为public型访问权限
        单下划线、双下划线、头尾双下划线说明：
            __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
            _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
            __foo: 双下划线的表示的是私有类型(private)的变量,只能是允许这个类本身进行访问了。
            
        函数也是如此。