python作为一种编程语言，诞生于1990年左右，算是一门比较年轻的语言（也算是90后吧），它是面向对象的，但不同于JAVA\C#那么严格要求一切皆对象，更接近于C++，是面向过程和面向对象的结合；它是解释型语言，但是也可以编译成 .pyc 跨平台的字节码文件（由类似于JAVA 的 .class 文件，由python虚拟机来执行），.pyc 文件有几个好处，一是可以简单的隐藏源码，二是提高载入速度，三是跨平台。
编译：python -m py_compile test.py 会生成 test.pyc 文件
python -O -m py_compile test.py 会生成 test.pyo 文件，就是 .pyc 的简单优化。
批量编译一个文件夹中所有的 .py 文件，可以使用 python -m compileall dirname
在 windows 下执行 .py/.pyc 文件时，默认会有闪现一个dos窗口，如果不要这个窗口，可以将 .py/.pyc 的文件后缀改成 .pyw 即可。
其实这种改动，并没有本质上的区别，真正的区别在于 .py/.pyc 文件默认调用 python.exe 来执行，而 .pyw 文件默认调用 pythonw.exe 执行，仅此而已。（w 表示窗口）
python 也有动态链接库，如 linux 下的 .so 或 windows 下的 .dll。
可以通过 python -m pdb test.py 来调试python程序，方法基本与gdb相同。
http://www.cnblogs.com/mindsbook/archive/2009/07/19/pdb.html
python 的用武之地
由于本人并非python开发者，所知有限，欢迎补充。
1、服务器维护脚本，比 shell 脚本可强大得多。
2、服务端程序
3、胶水程序，如游戏开发中的任务脚本等
4、WEB开发，如 django \web.py 等
5、手游开发，如 cocos-2dx 就有 python 版。
6、桌面应用开发，如 wxpython等等。
7、云，如 openstack
优点：
1、代码风格优雅（见仁见智了）
2、一次编写，随处运行（这句话不是JAVA的特权）
3、即写即运行
4、由于胶水特性，性能要求高的地方可以使用c/c++来编写。
5、简单易学，所以接下来，不必紧张，请愉快的学习它吧
6、开源
7、庞大的标准库
缺点：
1、tab 与 空格带来的噩梦
2、性能，不过可以通过胶水特性弥补
3、python2 与 3之间的抉择
python脚本的第一行一般是特定的，使用 #! 开始，其后紧跟着机器python解释器的路径。在一些LINUX系统上，为了避免硬编码 python 解释器的路径，也可以这样写： #!/usr/bin/env python
通过 import 可以导入一个模块，如果那个模块可执行，则执行此模块，但是，多次 import 同个模块，只会执行一次，因为导入是一个开销很大的工作，所以第一次导入时将其编译成字节码，并且运行代码。如果希望可以再次运行模块，可以使用
import imp
import hello
imp.reload(hello)
python2.6~2.7中，reload 是内置函数，不需要导入，即这样也是可以的：
import hello
reload(hello)
reload函数的返回值是一个python模块对象。
此外，还有一种方法，借助于 exec 函数：
exec(open('hello.py').read())
但这种方法不会导入模块，而是类似于宏替换，把文件中代码粘贴进来一样，如果变量有重名，会造成覆盖。
关于 from ... import ...
from 后跟模块名，即可当模块的文件名或文件夹名（文件夹中包括 __init__.py 文件），而 import 后跟模块中的属性名或方法名等。通过 dir(模块名) 可以返回模块中所有的可用的变量名列表
IDE
交互式解释器:windows\linux
源码执行：windows\linux
与 perl\php\lua\ruby 的对比
最近的语言使用排行榜。
python是蟒蛇的意思，如华蟒的由来。
不必紧张，请保持愉快，python是一门简单且功能强大的语言。
弱类型，但是大小写敏感。
int long float str bool
字符串是不可变的
注释
#!/usr/bin/python
#coding:utf-8
chmod +x test.py
分号的用武之地：
python可以不使用分号，唯一必须要使用分号的场所为将多行语句写在同一行的时候，如：
i=3;j=4
但推荐一行只写一个语句。将多行写成一行是不被推荐的，但有时却需要把一行写成多行，则需要使用行连接符号 \，如：
print \
i
另外，列表、元组可以不需要行连接符号，即可拆成多行书写，如：
mytuple=(3,
4,5,)
转义符 \
同一层次的语句必须要有相同的缩进。
不要混用制表符和空格来缩进。
SyntaxError: invalid syntax
int/int == int，如 3/2 的结果是1，同 c/c++，如果要得到浮点结果，则两数字至少要有一个是浮点数，如 3.0/2 或 3/2.0 即可。也可以 from __future__ import division ，或以 python -Qnew 的方式启动python交互解释器。
关于 import 与 include
str 与 repr(``)
input 与 raw_input
原始字符串 r
------------------------------------------------
序列和映射：
列表类似于其它语言中动态可变的数组，如 c++的vector，java的 arraylist ，索引也是从0开始，但不同的是，python的列表索引还可以从反向开始，最后一个元素为-1，倒数第二个为-2……
六种序列：列表、元组、字符串、Unicode字符串、buffer对象和 xrange对象。
元组用作配置文件的情况非常常见。
通用序列操作：
分片操作，如果熟知 go 语言，会有助于理解。
字符串是不可变的，更类似于 tuple。
格式化字符串，%s,%d,%f,%%
模板字符串
print 'ab','cd' 会输出 ab cd，中间会自带空格，如果不需要空格 print 'ab','\bcd' 即可，或 print 'ab'+'cd'
i = int() --> i = 0
b = bool() --> b = False
强制类型转换
str\unicode\basestring
print isinstance('a',basestring) 仅适用于 str 和 unicode
下面不仅适用于str和unicode,且适用于 UserString ,不过比较慢
def isStringLike(obj):
try:obj+''
except:return False
else: return True
print isStringLike(3)
闭包：
http://blog.csdn.net/marty_fu/article/details/7679297
dict的 copy 与 deepcopy
print 语句默认会在输出信息后加上换行符，如果不需要换行，则可以在行尾加上一个逗号，如：
print 'hello,',
print 'world'
序列解包：
x,y,z = 1,2,3
x,y = y,x
values = 1,2,3
x,y,z = values
FALSE:
False/None/0/''/()/[]/{}
比较运算符可以连在一起使用，如 0<age<100
is / is not
and / or 代替 &&/|| ，短路逻辑。没有 & / | 的非短路版本。
assert
没有类C语言的for循环语句，只有 for ... in 循环，类似于其它语言的 foreach
zip 并行迭代。
编号迭代。
翻转 reversed、排序迭代 sorted。
循环：while,for,列表推导式
其它语言用一个分号表示空语句，python使用 pass
exec/eval
命名空间：http://www.cnblogs.com/windlaughing/archive/2013/05/26/3100362.html
return 返回None，一般用来表示函数结束
默认参数传递是值传递，参数如果是列表，在函数内部操作列表索引，就可达到引用传递的效果，（但如果想整个给列表赋新值，也是不可以的。貌似传进来的参数，不能直接做为左值，否则就是新的变量）如：
def fun(lt):
lt[0]=3
mylt = [1,2,3,4]
fun(mylt)
print mylt
所以如果想改变参数，可以把值放在列表中。
关键字参数和默认值
可变参数 */**，前者用元组，表示可变的位置参数，jj后者用字典，表示可变的关键字参数
globals()["i"] 来引用全局变量 i
kkk
一些有意思的函数：
map/filter/reduce/sum/apply
关于 Unicode / utf-8 / ascii 编码：
http://blog.renren.com/share/68464/3096404244
http://blog.163.com/longsu2010@yeah/blog/static/173612348201173115733728/
import types
dir(types) 可以查看所有类型
import exceptions
dir(exceptions) 可以查看所有异常
dir(dict) 可以查看所有字典方法与属性
help(dict) 可以查看所有字典方法 （详细）
help(dict.pop) 可以查看指定方法或属性
x,y,z = 1,2,3
这种赋值称为多元赋值，左边当作元组，右边也当作元组。等同于 (x,y,z) = (1,2,3)
面向对象：
class A(object):
count = 0
def __init__(self,name):
self.name = name
self.__class__.count += 1
print '__init__'
print 'count:',self.__class__.count
def __del__(self):
print '__del__'
self.__class__.count -= 1
def msg(self):
print self.name
@staticmethod
def get_count1():
print 'staticmethod:',A.count
@classmethod
def get_count2(cls):
print 'classmethod:',cls.count
class B(A):
def __init__(self,name,age):
super(self.__class__,self).__init__(name)
self.age = age
def msg(self):
print self.name,self.age
a1 = A('a1')
a1.msg()
del a1
a2 = A('a2')
a2.msg()
print '----------------'
b1 = B('b1',18)
b1.msg()
A.get_count2()
A.get_count2()
@classmethod 的第一个参数是 cls，因此可以访问类变量，或是用作类工厂，而 @staticmethod 除了自身代码是位于类里面之外，对类的情况一无所知；@staticmethod 只适用于不想定义全局函数的情况。两者能做的事几乎一样，区别是更明晰的暴露使用意图，为了有更好的编程风格。
新式类和旧式类
python的新式类是2.2版本引进来的，我们可以将之前的类叫做经典类或者旧类。
为什么要在2.2中引进new style class呢？官方给的解释是：
为了统一类(class)和类型(type)。
在2.2之前，比如2.1版本中，类和类型是不同的，如a是ClassA的一个实例，那么a.__class__返回 ‘ class __main__.ClassA‘ ，type(a)返回总是<type 'instance'>。而引入新类后，比如ClassB是个新类，b是ClassB的实例，b.__class__和type(b)都是返回‘class '__main__.ClassB' ，这样就统一了。
引入新类后，还有其他的好处，比如更多的内置属性将会引入，描述符的引入，属性可以来计算等等。
为了向前兼容，默认情况下用户定义的类为经典类，新类需要继承自所有类的基类 object 或者继承自object的新类。
值得注意的地方是，虽然使用的是最新的python（2.7），但是一些特性不会在旧式类起作用。所以，为了确保自己使用的是新式类，有以下方法：
- 把这个赋值语句放在类模块代码的最前面 __metaclass__ = type（前面有提过）。
- 自己的类都从内建类object直接或者间接地继承。
当然，在Python3里面，不存在这些问题了，因为所有的类都是object类的子类（隐式）。
类实现迭代器如下：
#coding:utf-8
class Odd(object):
val,i = 1,1
def __init__(self,num,count=0):
self.num = num
self.count = count
def next(self):
if self.__class__.val > self.num:
raise StopIteration #只能使用这句才能退出循环
if self.count != 0 and self.__class__.i > self.count:
raise StopIteration
ret = self.__class__.val
self.__class__.val += 2
self.__class__.i += 1
return ret
def __iter__(self):
return self
#print list(Odd(100,3))
#for item in Odd(100,3):print item
while True:
try:
print Odd(100,3).next()
except StopIteration:
break
关于生成器，也是一种特殊的迭代器
#coding:utf-8
def odd(num,count=0):
val,i = 1,1
while val <= num:
yield val
val += 2
i += 1
#生成器退出的三种情况：
#1、执行到函数末尾，如此处的 val>num 时
#2、执行到 return 语句
#3、抛出 StopIteration 异常
if count != 0:
if i>count:
return
#raise StopIteration
for i in odd(100):
print(i)
print list(odd(100,3))
fun = odd(100,4)
while True:
try:
print fun.next()
except StopIteration:
break
将一段字符串中指定字符替换成指定字符：
s1 = '1234'
s2 = '5678'
s = '10203040'
print ''.join(dict(zip(list(s1),list(s2))).get(c,c) for c in s)
import string
print string.translate(s,string.maketrans(s1,s2))
import re
print re.sub('.',lambda m: dict(zip(list(s1),list(s2))).get(m.group(),m.group()),s)
第三种方法，目前暂不熟练。
try...except...else...finally
else子句是当没有捕捉到异常时执行的语句，表示正常运行。
finally是不管有没有捕捉到异常都必然执行的语句
如果 except 后面没有跟上指定异常（或异常元组），则默认为全捕捉，这是很危险的，因为它也会捕捉语法或书写方面的异常，如 AttributeError 、 IndentationError 和SyntaxError。
不同于C/C++，python的赋值语句不能做为表达式，即没有返回值。
python3.2教程：
http://docspy3zh.readthedocs.org/en/latest/tutorial/index.html