语句和表达式区别：语句使用关键字来组成命令，类似告诉解释器一个命令；
表达式没有关键字。
python中未指定返回值的函数会自动返回None，等价于NULL。
1、程序输出
当希望输出变量内容时，会在代码中使用print语句输出。不过在交互式解释器中，既可以用print语句显示变量的字符串表示，也可以仅使用变量名查看
该变量的原始值：
[root@client1 ~]# python
Python 2.4.3 (#1, May 5 2011, 16:39:10)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-50)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'
>>>
注意：在仅使用变量名时，输出的字符串时被用单引号括起来的。这是为了让非字符串对象也能以字符串的方式显示在屏幕上------即它显示的是该
对象的字符串表示，而不仅仅是字符串本身。引号表示你刚刚输入的变量的值是一个字符串。
2、程序输入和raw_input()内建函数
下划线(_)表示：最后一个表达式的值：
>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'
>>> _
'Hello World!'
Python的print语句与字符串格式运算符%结合使用，可实现字符串替换功能：
>>> print "%s is number %d" %("python",1)
python is number 1
从python2.0开始，使用>>实现重定向输出
raw_input()读取标准输入，并将读取到的数据赋值给指定的变量。
>>> usr = raw_input('Enter login name:')
Enter login name:root
>>> print 'Your login is:',user
Your login is:
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'user' is not defined
>>> print 'Your login is:',usr
Your login is: root
可以用int()内建函数将用户输入的的字符串转换成整数：
>>> num = raw_input('Now enter a number:')
Now enter a number:1024
>>> print 'Doubling your number: %d' %(int(num) *2)
Doubling your number: 2048
如果想得到一个生疏函数的帮助，可以使用help()内建函数：help(raw_input)
raw_input()从标准输入读取一个字符串，并自动删除串尾的换行字符，如果用户键入了EOF字符（Unit:Ctrl+D，Windows:Ctrl+Z+回车），则引发
EOFError。如果需要提供提示字符串参数，则显示该字符串并自动删去字符串末尾的换行字符。
3、注释
从#开始，直到一行结束的内容都是注释
>>> #one comment
... print 'hello world' #another comment
hello world
名为文档字符串的特别注释：可以在模块、类或者函数的起始添加一个字符串，起到在线文档的功能。与普通文档不同，文档字符串可以在运行时
访问，也可以用来自动生成文档。
def foo():
"This is a doc string."
return True
4、运算符
+ - * / // % **
‘/’表示传统除法，即如果两个操作数都是整数的话，它将执行地板除（取比商小的最大整数）。
‘//’表示浮点除法（对结果进行四舍五入）
优先级：乘方(**) > 单目运算符-+ > * / // % >加减+-
< <= > >= == != <>(弃用)
>>> 2 < 4
True
>>> 2 ==4
False
>>> 2 > 4
False
>>> 6.2 < 6
False
>>> 6,2 <= 6.2
(6, True)
>>> 6.2 <= 6
False
>>> 6.2 <= 6.2000
True
>>> 6.2 < 6.2
False
and or not
>>> 2 < 4 and 2 == 4
False
>>> 2 > 4 or 2 < 4
True
>>> not 6.2 <=6
True
>>> 3 < 4 < 5
True
上面3 <4 <5是下面的缩写
>>> 3 < 4 and 4 < 5
True
需要合理的使用括号增强代码可读性。
5、变量和赋值
变量名：字母、下划线开头。其余的字符可以是数字、字母或下划线。
Python对大小写敏感。
Python是动态类型语言，不需要预先声明变量的类型，变量的类型和值在赋值那一刻被初始化，变量赋值使用等号执行。
python支持:n *= 10，但是不支持C语言中的自增和自减运算符，Python会将--n解释为-(-n)，从而得到n，同样++n的结果也是n，因为+-也是
表示正负的单目运算符。
6、数字
Python支持五种基本数字类型：
int： 有符号整数
long： 长整数，不要与C语言长整数混淆，python的长整型仅受限于用户计算机虚拟内存总数。
未来版本中，int和long将会无缝结合，长整数后缀"L"也变得可有可无。
bool： 布尔值，将布尔值用到一个数值上下文环境中（如将True与一个数字相加），True会被当成数值1，而False会被当成整数值0.
float： 浮点值
complex：复数
在导入decimal模块后，可以使用decimal数值类型，用于十进制浮点数。
由于在二进制表示中有一个无限循环片段，数字1.1无法用二进制浮点数精确表示，数字1.1实际上会被表示成：
>>> 1.1
1.1000000000000001
>>> import decimal
>>> print decimal.Decimal('1.1')
1.1
7、字符串
Python中字符串被定义为引号之间的字符集合，支持成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可用来包含特殊字符。
支持使用索引运算符([])和切片运算符([:])可以得到子字符串，字符串有其特有的索引规则：第一个字符的索引是0，最后一个字符的索引是-1.
加号(+)用于字符串连接，星号(*)用于字符串重复。
>>> pystr = '''python
... is cool'''
>>> pystr
'python\nis cool'
>>> print pystr
python
is cool
8、列表和元组
同一列表和元组能保存任意数量任意类型的python对象，以0开始索引
列表：[]，元素个数及元素的值可以改变
元组：()，不可更改
使用切片运算[]和[:]可以得到子集。
>>> aList = [1,2,3,4]
>>> aList
[1, 2, 3, 4]
>>> aList[0]
1
>>> aList[2:]
[3, 4]
>>> aList[:3]
[1, 2, 3]
>>> aList[1] = 5
>>> aList
[1, 5, 3, 4]
元组中数值不可改变：
>>> aTuple = ('robots',77,93,'try')
>>> aTuple
('robots', 77, 93, 'try')
>>> aTuple[:3]
('robots', 77, 93)
>>> aTuple[1] = 5
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
9、字典
字典由键-值(key-value)对构成，几乎所有类型的Python对象都可以用作键，不过一般还是以数字或者字符串最为常用。
值可以是任意类型的Python对象，字典元素用大括号({})包裹
>>> aDict = {'host':'earth'}#create dict
>>> aDict['port'] = 80 # add to dict
>>> aDict
{'host': 'earth', 'port': 80}
>>> aDict.keys()
['host', 'port']
>>> aDict['host']
'earth'
>>> for key in aDict:
... print key,aDict[key]
...
host earth
port 80
10、代码块及缩进对齐
代码块使用缩进对齐来表达代码逻辑，而不是使用大括号。
11、if语句
if expression1:
if_suite
elif expression2:
elif_suite
else:
else_suite
python中条件表达式并不需要加括号。
12、while循环
while expression:
while_suite
>>> counter = 0
>>> while counter < 3:
... print 'loop #%d' %(counter)
... counter += 1
...
loop #0
loop #1
loop #2
13、for循环和range()内建函数
Python里面的for循环更像shell里面的foreach。Python中的for接受可迭代对象(例如序列或迭代器)作为其参数，每次迭代其中一个元素：
>>> print 'I like to use the Internet for:'
I like to use the Internet for:
>>> for item in ['e-mail','net-surfing','homework','chat']:
... print item
...
e-mail
net-surfing
homework
chat
print语句默认给每一行添加一个换行符，只要在print语句的最后添加一个逗号(，)就可以改变这种行为，而且加逗号的print语句会在输出的元素之间会自动添加一个空格：
>>> print 'I like to use the Internet for:'
I like to use the Internet for:
>>> for item in ['e-mail','net-surfing','homework','chat']:
... print item,
...
e-mail net-surfing homework chat
>>> who = 'knights'
>>> what = 'Ni!'
>>> print 'We are the',who,'who say',what,what,what,what
We are the knights who say Ni! Ni! Ni! Ni!
>>> print 'We are the %s who say %s'% \
... (who,((what + ' ')*4))
We are the knights who say Ni! Ni! Ni! Ni!
要达到递增数值的效果：
>>> for eachNum in [0,1,2]:
... print eachNum,
...
0 1 2
因为我们要使用的数值范围经常变化，python提供了range()内建函数来生成这种列表
>>> for eachNum in range(3):
... print eachNum
...
0
1
2
对字符串来说，很容易迭代每一个字符：
>>> for c in foo:
... print c,
...
a b c
range()经常和len()一起用于字符串索引，下面显示的是每一个元素及其索引值：
>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i],'(%d)'%i
...
a (0)
b (1)
c (2)
上述循环存在约束：要么循环索引，要么循环元素，这导致了enumerate()函数推出，它同时做到了这两点：
>>> for i, ch in enumerate(foo):
... print ch, '(%d)'%i
...
a (0)
b (1)
c (2)
14、列表解析
可以在一行中使用一个for循环将所有值放到一个列表当中
>>> sqdEvents = [x ** 2 for x in range(8) if not x %2]
>>>
>>> for i in sqdEvents:
... print i
...
0
4
16
36
15、文件和内建函数open()、file
如何打开文件：
handle = open(file_name, access_mode = 'r')
file_name 变量包含我们希望打开的文件的字符串名字， access_mode 中 'r' 表示读取，
'w' 表示写入， 'a' 表示添加。其它可能用到的标声还有 '+' 表示读写， 'b'表示二进制访
问. 如果未提供 access_mode ， 默认值为 'r'。如果 open() 成功， 一个文件对象句柄会被
返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后， 我们就可
以访问它的一些方法， 比如 readlines() 和close().文件对象的方法属性也必须通过句点属
性标识法访问。
访问属性的方法：句点属性标识法，即在对象名和属性名之间加一个句点：object.attribute
filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine,
fobj.close()
对于print eachLine，后面带逗号，是为了抑制出现\n，因为每行已经有自带的换行符了，不抑制\n会出现额外的空行。
此外，这是将文件内容一次性读出，然后再逐行显示。
16、错误和异常
编译时会检查语法错误，Python也允许在程序运行时检测错误。当检测到一个错误，Python解释器就引发一个异常，并显示异常的详细信息。
要给你的代码添加错误检测及异常处理，只要将它们封装在try-except语句中。try之后的代码组是你打算管理的代码。except之后的代码组，则是你处理错误
的代码。
>>> try:
... filename = raw_input('Enter file name: ')
... fobj = open(filename,'r')
... for eachLine in fobj:
... print eachline,fobj.close()
... except IOError,e:
... print 'file open error:',e
...
Enter file name: test
file open error: [Errno 2] No such file or directory: 'test'
程序员也可以用raise语句故意引发一个异常。
17、函数
函数在调用前必须先定义。如果函数中没有return语句，则会自动返回None对象。Python是通过引用调用的，这意味着函数内对参数的改变会影响到原始对象。
不过事实上只有可变对象会受此影响，对不可变对象来说，它的行为类似按值调用。
def function_name([arguments])：
"optional documentation string"
function_suite
参数中[]表示参数可选，调用python函数时不能省略()。
‘+’对于数字是两数之和，对于字符串则是两个字符串连接，对应列表，则是：
>>> [1,2] + [3,4]
[1, 2, 3, 4]
函数的参数可以有一个默认值，如果提供有默认值：在函数定义中，参数以赋值语句定义。在提供默认值的情况下，如果函数调用时没提供这个参数，就取这个值
作为默认值。
>>> def foo(debug=True):
... 'determine if in debug mode with default argument'
... if debug:
... print 'in debug mode'
... print 'done'
...
>>> foo()
in debug mode
done
>>> foo(False)
done
18、类
定义类：
class ClassName(base_class[es])：
"optional documentation string"
static_member_declarations
method_declaration
使用class关键字定义类，可以提供一个可选的基类，如果没有合适的基类，那就使用object作为基类。
>>> class FooClass(object):
... """my very first class: FooClass"""
... version = 0.1 # class (data) attribute
... def __init__(self, nm='John Doe'):
... """constructor"""
... self.name = nm # class instance (data) attribute
... print 'Created a class instance for', nm
... def showname(self):
... """display instance attribute and class name"""
... print 'Your name is', self.name
... print 'My name is', self.__class__.__name__
... def showver(self):
... """display class(static) attribute"""
... print self.version #references FooClass.version
... def addMe2Me(self,x): #does not use 'self'
... """apply + operation to argument"""
... return x + x
...
上面定义的version是一个静态变量，它将被所有实例及四个方法共享。
__init__()方法有一个特殊的名字，所有名字开始和结束都有两个下划线的方法都是特殊方法。当一个类实例被创建时，__init__()会自动执行，在类实例创建完毕
后执行，__init__()可以被当成构建函数，但是它并不创建实例----它仅仅是你的对象创建后执行的第一个方法，它的目的是执行一些该对象的必要的初始化工作。
通过创建自己的__init__()方法，可以覆盖默认的__init__()方法（默认的方法什么也不做）。
在该例子中，初始化了一个名为name的类实例属性，这个变量仅在类实例中存在，它并不是实际类本身的一部分。__init__()需要一个默认的参数。
self是类实例自身的引用，类似其他语言的this
创建类实例
>>> foo1 = FooClass()
Created a class instance for John Doe
>>> foo1.showname()
Your name is John Doe
My name is FooClass
>>>
>>> foo1.showver()
0.1
>>> print foo1.addMe2Me(5)
10
>>> print foo1.addMe2Me('xyz')
xyzxyz
对于一个实例来说，self.__class__.__name__表示实例化它的类的名字，self.__class__引用实际的类。
上例没有提供参数，使用的是默认参数'John Doe'，下例是提供了参数：
>>> foo2 = FooClass('Jane Smith')
Created a class instance for Jane Smith
>>> foo2.showname()
Your name is Jane Smith
My name is FooClass
19、模块
模块是一种组织形式，它将彼此有关系的Python代码组织到一个个独立文件当中。模块可以包含可执行代码，函数和类或者这些东西的组合。
当你创建了一个python源文件，模块的名字就是不带.py后缀的文件名，一个模块创建后，可从另一个模块中使用import语句导入这个模块来使用：
import module_name
访问一个模块函数或访问一个模块变量：
一旦导入完成，可用句点属性标识法访问：
module.function()
module.variable
使用示例：
>>> import sys
>>> sys.stdout.write('Hello World!\n')
Hello World!
>>> sys.platform
'linux2'
>>> sys.version
'2.4.3 (#1, May 5 2011, 16:39:10) \n[GCC 4.1.2 20080704 (Red Hat 4.1.2-50)]'
里面的write()不会自动在字符串后面添加换行符号，所以需要显示添加'\n'
20、实用函数
内建函数： 描述
dir([obj]) 显示对象的属性，如果没有提供参数， 则显示全局变量的名字
help([obj]) 以一种整齐美观的形式 显示对象的文档字符串， 如果没有提供任何参
数， 则会进入交互式帮助。
int(obj) 将一个对象转换为整数
len(obj) 返回对象的长度
open(fn, mode) 以 mode('r' = 读， 'w'= 写)方式打开一个文件名为 fn 的文件
range([[start,]stop[,step]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start
默认值为 0， step默认值为1。
raw_input(str) 等待用户输入一个字符串， 可以提供一个可选的参数 str 用作提示信
息。
str(obj) 将一个对象转换为字符串
type(obj) 返回对象的类型（返回值本身是一个type 对象！）