笔者对于python常用的语法知识做了小结，不是很全面，希望能给各位带来帮助。
1.同一级代码的缩进必须保持一致，需要缩进的位置使用“：”
2.raw_input函数 eg:name=raw_input('input your name:')
3.import函数用于引入库 eg:import math;math.cos(0.5)
4.python的数据类型：
(1)数字： '%x'十六进制 '%o'八进制 '19+2j'表示复数
(2)相关运算符
(3)字符串概述： \n \t '\'用于打印转义字符 相关字符串操作函数。
str[1:-1] 表示从第二个到最后一个，不包括最后一个。
字符串的拼接可以直接使用加号 '3'+'4'='34'。
(4)列表和元组： 列表是以方括号“[]”包围的数据集合，不同成员之间以","分隔。列表的元素可以是任何的类型，通过序号访问其中的值。range(1,6)可用于
产生包含整数1到5的列表，注意是5不是6。
元组是以圆括号“()”包围的数据集合，元组的元素一旦确立就不能被改变。
python提供了关于列表操作的强大支持，有很多相关的函数。
(5)字典： 字典是python中比较特别的数据类型，以“{}”包围的数据集合。字典与列表的最大不同是字典是无序的，在字典中通过“键”来访问成员。字典是可
变的，可以包含任何其他的类型。字典中的成员是以“键：值”的形式来声明的。
(6)文件： 用到在看吧。
5.python基本语句
(1) if语句： if <条件>： 比较运算符：a==b a!=b a>=b a<=b a>b a<b
<语句>
elsif<条件>： if语句可以嵌套。
<语句>
else：
<语句>
(2)for语句： for <> in <对象集合>： 注意:else语句块是与for语句对应的，注意缩进。
if <条件>：
break
if <条件>： for语句中的对象集合可以是列表，元组和字典。常用的是使用range函数产生整数列表完成计数循环。
continue
<其他语句>
else：
<语句块>
(3)while语句： while<条件>： while语句只有在测试语句为假时，循环才会停止。while语句同样有一个可选的else语句，如果while没有被break终止，
if<条件>： 就会执行else语句块。
break
if<条件>：
continue
<语句块> 与for相似，else语句与while相对应，注意缩进。
else：
<语句块>
6.python函数与模块 所有的python函数必须先声明，才能在脚本中使用。
a.函数
(1)函数声明：使用def语句可以声明一个函数，完整的函数是由函数名，参数以及函数实现语句组成的。函数中也要使用缩进来表示函数体，如果函数用返回值，使用
return返回需要的值。
格式：def <函数名> (参数列表)：
<函数语句>
return <返回值>
其中参数列表和返回值不是必须的。
(2)函数调用：函数调用的方式与c相同。
b.函数中的参数
(1)参数默认值：python可以在函数声明时，将参数声明成一个默认的值。如果调用时不给出参数，就使用默认的参数。python中还可以声明一个具有任意个参数的函数。
(2)参数的传递：参数的传递是严格按照声明时的顺序进行的；python还提供了另外一种按照参数名进行传递的方式；同时存在时顺序传递的方式要在按参数之前。
(3)可变长参数：声明一个可变长参数的函数只需以“*”开头定义一个参数即可。
eg: def mylistappend(*list)：
l=[];
for i in list:
l.extend(i)
return l
(4)参数引用：在python中，在参数中使用可变对象，可以达到改变参数的目的。
整数是不可改变对象，列表是可改变对象。
c.作用域
python作用域分为内置作用域，全局作用域和局部作用域。除非用以上提到的参数应用方法，函数内的操作不会改变函数外的变量。而在函数内想要使用函数外的变量要使用global关键字。
eg：def fun(x)：
global a
return a+x
结果：
...
>>>a=5
>>>fun(3)
8
d.lambda表达式
lambda表达式可以声明一个匿名函数,使用形式如下：
lambda 参数列表：表达式
eg: >>>fun=lambda x:x*x+x
>>>fun(2)
6
>>>def show(x):
... print 'lambda'*x
...
>>>funn=lambda x:show(x)
>>>funn(2)
lambdalambda
f.模块 python中的模块是包含函数和其他语句的python脚本文件，它以".py"为后缀名。
(1)模块概述：导入模块：使用以下两种方式导入:
import 模块名
from 模块名 import 函数名 from strings import *(表示导入模块中的所有函数)。
注：可以利用reload重新载入模块。该模块事先必须已经被导入。
编写一个模块：模块中写入函数与变量，引用方式为"模块名.函数名/变量名" eg:mymodule.show()
模块查找路径：linux相关的内容
模块编译：将".py"文件编译为".pyc"文件。
模块独立运行—————_name_属性：如果python脚本以模块被导入，其_name_属性被设置为模块名；如果单独运行，_name_属性被设置为"_main_"可以
以此来判断模块的运行状态。
dir()函数：利用dir()函数获得当前脚本的名字列表。
(2)模块包：包可以看作是处于同一目录中的模块。在包的每一个目录里都必须包含一个名为"_init_.py"的空文件。
7.面向对象的python
a.概述：
(1)类和对象：
类是面向对象程序设计的基础。类具有抽象性，封装性，继承性和多态性。
类的抽象性是指类是对具有共同方法和属性的一类对象的描述。
类的封装性是指类将属性和方法封装，对于外部其是不可见的，只有通过类提供的接口才能与属于类的实例对象进行数据交换。
类的继承性是指类可以由已有的类派生。派生出来的类拥有父亲的方法和属性。
类的多样性是指类可以根据不同的参数类型调用不同的方法。python在这个方面做的还很好。
每个类都有自己的属性和方法。类的属性就是指类的内部定义的变量，类的方法是指内部定义的函数。
对象是具体的事物，是实例化后的类。
b.类的基础：
(1)类的定义：
类的定义使用的class语句，在定义类时，也要采用缩进的语句表示属于该类。
eg:class<类名>：
<语句1>
<语句2>
...
<语句3>
类的定义一般放在脚本文件的头部，也可以定义在if语句中或者函数里。
类还可以通过继承的形式获得：
eg:class<类名>(父亲名)：
<语句1> #可用与定义新的属性
...
<语句2>
类内部的名字空间与函数类似属于局部作用域。
eg:>>>class human:
... age=0
... name=''
... sex=''
...
>>>class stu(human):
... school='' #定义了新的类属性。
... grade=0
...
(2)类的使用
类的定义必须先实例化后才能够使用，用法与函数类似。
eg:>>>class book:
... name=''
... author=''
... pages=0
... price=0
...
>>>a=book() #对于类的使用
>>>a.name
''
>>>a.name='the byte of python'
>>>a.name
the byte of python
在python中特别的是，实际创建一个类后就可以通过类名访问其中的属性。
c.类的属性和方法
(1)类的属性 类的公有属性和私有属性
类的私有属性在类的外部不能更改。在python中，类中的属性以两条下划线开始的话为私有属性。
eg:>>> class human:
... name=''
... sex=''
... _love='zq'
...
>>> c=human()
>>> c._love
'zq'
>>> c._love='zhouqi'
>>> c._love
'zhouqi'
>>> class stu(human):
... __lover='zhouxiaoqi'
...
>>> b=stu()
>>> b.__lover
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: stu instance has no attribute '__lover'
>>>
访问私有属性会报错。想要获取或者修改私有属性的值，要使用到类的方法。
(2)类的方法 类的方法实际上就是类内部使用def关键字定义的函数。特别的是类的方法必须包含参数self，且self必须是第一个参数。
与类的属性相似，类的方法也分为类的公有方法和类的私有方法，类的私有方法名同样以两个下划线开头，在类的内部调用使用"self.私有方法名"的格式
类的专有方法：在python中有一类以两条下划线开始又以两条下划线结束的方法称之为类的专用方法。
eg:>>> class book:
... __author=''
... __name=''
... __page=0
... price=0
... __press=''
... def __check(self,item):
... if item == '':
... return 0
... else:
... return 1
... def show(self):
... if self.__check(self.__author):
... print self.__author
... else:
... print 'no vaule'
... if self.__check(self.__name):
... print self.__name
... else:
... print 'no vaule'
... def __init__(self,author,name):
... self.__author=author
... self.__name=name
...
>>> a=book('zhouqi','the byte of python')
>>> a.show
<bound method book.show of <__main__.book instance at 0x7fd1426fb128>>
>>> a.show()
zhouqi
the byte of python
(3)类的继承
通过继承创建类时有一个问题要注意：新类可以继承父亲的公有属性和方法，不能继承私有属性和方法。在新类中调用会造成错误。
多重继承：是指创建的类有多个类的属性和方法，一般形式如下：
>>>class 新类名(父亲名1,父亲名2.....)
<语句名1>
...
注意对于父亲中有重名的情况的处理。
eg:>>>class C(A,B) #假设A，B中定义了show方法
show=B.show #可用这种形式来指定，与C++不同。
(4)重载
重载允许通过继承而创建的类重新定义父亲的方法。
方法重载：在新类中创建相同名字的函数，并在函数中以"父亲.方法"的形式调用父亲的方法。
运算符重载：python中有固定的函数。
亮点代码: def __init__(self,*arg):
self.__mylist = []
for arg in args:
self.__mylist.append(arg)
def __add__(self,n): #重载 + 运算符
for i in rang(0,len(self.__mylist)):
self.__mylist[i]=self.__mylist[i]+n
8 异常与调试
a.常见的异常有除零，和下标越界等。
b.使用pdb调试python脚本:
pdb模块可以通过import语句导入。pdb模块的函数可以分为以下几类：
(1)运行语句：
利用run函数来调试语句块：
eg:>>> import pdb
>>> pdb.run('''for i in range(0,3):
... i=i**2
... print i
... ''')
> <string>(1)<module>()
(Pdb) n
> <string>(2)<module>()
(Pdb) n
> <string>(3)<module>()
(Pdb) n
0
> <string>(1)<module>()
(Pdb) n
> <string>(2)<module>()
(Pdb) n
> <string>(3)<module>()
(Pdb) n
1
> <string>(1)<module>()
(Pdb)
> <string>(2)<module>()
(Pdb) n
> <string>(3)<module>()
(Pdb) n
4
> <string>(1)<module>()
(Pdb) print i
4
(Pdb) n
--Return--
> <string>(1)<module>()->None
(Pdb)
(2)运行表达式：在python中可以使用pdb模块的runeval函数来调试表达式。
eg:>>> import pdb
>>> l=[1,2,3]
>>> pdb.runeval('l[1]')
> <string>(1)<module>()
(Pdb) n
--Return--
> <string>(1)<module>()->2
(Pdb) n
2
>>> pdb.runeval('3+5*6/2')
> <string>(1)<module>()->2
(Pdb) n
--Return-- #return指的是什么？
> <string>(1)<module>()->18
(Pdb) n
18
>>>
(3)运行函数：在python中可以用pdb模块的runcall来调试函数
eg:>>> import pdb
>>> def sum(*args):
... r=0
... for arg in args:
... r=r+arg
... return r
...
>>> pdb.runcall(sum,1,2,3,4)
> <stdin>(2)sum()
(Pdb) n
> <stdin>(3)sum()
(Pdb) n
> <stdin>(4)sum()
(Pdb) n
> <stdin>(3)sum()
(Pdb) print r
1
(Pdb) n
> <stdin>(4)sum()
(Pdb) print r
1
(Pdb) n
> <stdin>(3)sum()
(Pdb) print r
3
(Pdb) n
> <stdin>(4)sum()
(Pdb) n
> <stdin>(3)sum()
(Pdb) print r
6
(Pdb)
(4)设置硬断点 在python中可以使用pdb模块的set_trace函数在脚本中设置硬断点。set_trace函数一般在".py"文件中使用。
eg:利用gedit编写以下程序：
import pdb
pdb.set_trace()
for i in range(0,5):
i=i*5
print i
在主目录中存为import.py
zd@zd:~$ python import.py
> /home/zd/import.py(3)<module>()
-> for i in range(0,5):
(Pdb) n
> /home/zd/import.py(4)<module>()
-> i=i*5
(Pdb) n
> /home/zd/import.py(5)<module>()
-> print i
(Pdb) n
0
> /home/zd/import.py(3)<module>()
-> for i in range(0,5):
(Pdb) continue
5
10
15
20