Python 的特点

　　1. 简单

　　　　Python 是一种代表简单思想的语言。

　　2. 易学

　　　　Python 有极其简单的语法。

　　3. 免费、开源

　　　　Python 是 FLOSS（自由 / 开放源码软件）之一。

　　4. 高层语言

　　　　使用 Python 编写程序时无需考虑如何管理程序使用的内存一类的底层细节。

　　5. 可移植性

　　　　Python 已被移植到很多平台，这些平台包括 Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、

　　BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、

　　Windows CE 甚至还有 PocketPC。

　　6. 解释性

　　　　可以直接从源代码运行。在计算机内部，python 解释器把源代码转换为字节码的中间形式，然后再把它翻译成计算机使用的机器语言。

　　7. 面向对象

　　　　Python 既支持面向过程编程也支持面向对象编程。

　　8. 可扩展性

　　　　部分程序可以使用其他语言编写，如 c/c++。

　　9. 可嵌入型

　　　　可以把 Python 嵌入到 c/c++ 程序中，从而提供脚本功能。

　　10. 丰富的库

　　　　Python 标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、

　　电子邮件、XML、XML-RPC、HTML、WAV 文件、密码系统、GUI（图形用户界面）、Tk 和其他与系统有关的操作。

--------------- 分割线 ------------------------ 以下是 Python 的基本语法 ---------------------------------------------------------

一、基本概念

　　1. python 中数有四种类型：整数、长整数、浮点数和复数。

• 整数， 如 1
• 长整数 是比较大的整数
• 浮点数 如 1.23、3E-2
• 复数 如 1 + 2j、 1.1 + 2.2j

　　2. 字符串（字符的序列）

• python 中单引号和双引号使用完全相同。
• 使用三引号 (''' 或 """) 可以指定一个多行字符串。
• 转义符 '\'
• 自然字符串， 通过在字符串前加 r 或 R。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
• python 允许处理 unicode 字符串，加前缀 u 或 U， 如 u"this is an unicode string"。
• 字符串是不可变的。
• 按字面意义级联字符串，如 "this" "is" "string" 会被自动转换为 this is string。

　　3. 标识符的命名

• 第一个字符必须是字母表中字母或下划线 '_'。
• 标识符的其他的部分有字母、数字和下划线组成。
• 标识符对大小写敏感。

　　4. 对象

　　　　python 程序中用到的任何“东西”都成为“对象”。

　　5. 逻辑行和物理行

　　　　物理行是我们在编写程序时看到的，逻辑行则是 python 看到的。

　　　　python 中分号; 标识一个逻辑行的结束，但是实际中一般每个物理行只写一个逻辑行，可以避免使用分号。

　　　　多个物理行中可以写一个逻辑行，如下：

s = "peter is \

writing this article"

　　　　上面 \ 的使用被称为‘明确的行连接’， 又如：

print \
"peter"

　　6. 缩进

　　　　空白在 python 是非常重要的，行首的空白是最重要的，又称为缩进。行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而决定语句

　　分组。这意味着同一层次的语句必须有相同的缩进，每一组这样的语句称为一个块。

　　注意：不要混合使用空格和制表符来缩进，因为在跨越不同的平台时无法正常工作。

二、运算符与表达式

　　1. 运算符与其用法

 　　2. 运算符优先级（从低到高）

 　　3. python 控制台输出 使用 print

print "abc"  　　#打印 abc 并换行
print "abc%s" % "d"  　　#打印 abcd
print "abc%sef%s" % ("d", "g")  　　#打印 abcdefg

三、控制流

　　1. if 语句

i = 10
n = int(raw_input("enter a number:"))
if n == i:
print "equal"
elif n < i:
print "lower"
else:
print "higher"

 　　2. while 语句

while True:
pass
else:
pass
#else 语句可选，当 while 为 False 时，else 语句被执行。 pass 是空语句。

　　3. for 循环 for..in

for i in range(0, 5):
print i
else:
pass
# 打印 0 到 4

　　注：当 for 循环结束后执行 else 语句；

　　　　range(a, b) 返回一个序列，从 a 开始到 b 为止，但不包括 b，range 默认步长为 1，可以指定步长，range(0,10,2)；

　　4. break 语句

　　　　终止循环语句，如果从 for 或 while 中终止，任何对应循环的 else 将不执行。

　　5. continue 语句

　　　　continue 语句用来调过当前循环的剩余语句，然后继续下一轮循环。

四、函数

　　函数通过def定义。def 关键字后跟函数的标识符名称，然后跟一对圆括号，括号之内可以包含一些变量名，该行以冒号结尾；接下来是一块语句，即函数体。

def sumOf(a, b):
return a + b

　　1. 函数形参

　　　　函数中的参数名称为‘形参’，调用函数时传递的值为‘实参’

　　2. 局部变量

　　　　在函数内定义的变量与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是局部的。这称为变量的作用域。

　　　　global 语句， 为定义在函数外的变量赋值时使用 global 语句。

def func():
global x
print "x is ", x
x = 1
x = 3
func()
print x
#3
#1 

　　3. 默认参数

　　　　通过使用默认参数可以使函数的一些参数是‘可选的’。

def say(msg, times =  1):
print msg * times
say("peter")
say("peter", 3)

　　　　注意：只有在形参表末尾的那些参数可以有默认参数值，即不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参，只是因为赋给形参的值是根据位置而赋值的。

　　4. 关键参数

　　　　如果某个函数有很多参数，而现在只想指定其中的部分，那么可以通过命名为这些参数赋值（称为‘关键参数’）。

　　　　优点：不必担心参数的顺序，使函数变的更加简单；假设其他参数都有默认值，可以只给我们想要的那些参数赋值。

def func(a, b=2, c=3):
print "a is %s, b is %s, c is %s" % (a, b, c)
func(1) #a is 1, b is 2, c is 3
func(1, 5) #a is 1, b is 5, c is 3
func(1, c = 10) #a is 1, b is 2, c is 10
func(c = 20, a = 30) #a is 30, b is 2, c is 20

　　5. return 语句

　　　　return 语句用来从一个函数返回，即跳出函数。可从函数返回一个值。

　　　　没有返回值的 return 语句等价于 return None。None 表示没有任何东西的特殊类型。

　　6. DocStrings (文档字符串)

def func():
'''This is self-defined function
Do nothing'''
pass
print func.__doc__
#This is self-defined function
#
#Do nothing

五、模块

　　模块就是一个包含了所有你定义的函数和变量的文件，模块必须以.py 为扩展名。模块可以从其他程序中‘输入’(import) 以便利用它的功能。

　　在 python 程序中导入其他模块使用 'import', 所导入的模块必须在 sys.path 所列的目录中，因为 sys.path 第一个字符串是空串 '' 即当前目录，所以程序中可导入当前目录的模块。

 　　1. 字节编译的.pyc 文件

　　　　导入模块比较费时，python 做了优化，以便导入模块更快些。一种方法是创建字节编译的文件，这些文件以.pyc 为扩展名。

　　　　pyc 是一种二进制文件，是 py 文件经编译后产生的一种 byte code，而且是跨平台的（平台无关）字节码，是有 python 虚拟机执行的，类似于

　　java 或.net 虚拟机的概念。pyc 的内容，是跟 python 的版本相关的，不同版本编译后的 pyc 文件是不同的。

　　2. from .. import

　　　　如果想直接使用其他模块的变量或其他，而不加 '模块名 +.' 前缀，可以使用 from .. import。

　　　　例如想直接使用 sys 的 argv，from sys import argv 或 from sys import *

　　3. 模块的 __name__

　　　　每个模块都有一个名称，py 文件对应模块名默认为 py 文件名，也可在 py 文件中为 __name__ 赋值；如果是 __name__，说明这个模块被用户

　　单独运行。

　　4. dir() 函数

　　　　dir(sys) 返回 sys 模块的名称列表；如果不提供参数，即 dir()，则返回当前模块中定义名称列表。

　　　　del -> 删除一个变量 / 名称，del 之后，该变量就不能再使用。

六、数据结构

　　python 有三种内建的数据结构：列表、元组和字典。

　　1. 列表

　　　　list 是处理一组有序项目的数据结构，列表是可变的数据结构。列表的项目包含在方括号 [] 中，eg: [1, 2, 3]， 空列表 []。判断列表中是否包含某项可以使用 in， 比如 l = [1, 2, 3]; print 1 in l; #True；支持索引和切片操作；索引时若超出范围，则 IndexError；使用函数 len()查看长度；使用 del 可以删除列表中的项，eg: del l[0] # 如果超出范围，则 IndexError

　　　　list 函数如下：

　　　　append（value）　　--- 向列表尾添加项 value

l = [1, 2, 2]
l.append(3) #[1, 2, 2, 3]

　　　　count(value)　　--- 返回列表中值为 value 的项的个数

l = [1, 2, 2]
print l.count(2) # 2

　　　　extend(list2)　　--- 向列表尾添加列表 list2

l = [1, 2, 2]
l1 = [10, 20]
l.extend(l1)
print l   #[1, 2, 2, 10, 20]

　　　　index(value, [start, [stop]])　　--- 返回列表中第一个出现的值为 value 的索引，如果没有，则异常 ValueError

l = [1, 2, 2]
a = 4
try:
print l.index(a)
except ValueError, ve:
print "there is no %d in list" % a

　　　　insert(i, value)　　--- 向列表 i 位置插入项 vlaue，如果没有 i，则添加到列表尾部

l = [1, 2, 2]
l.insert(1, 100)
print l #[1, 100, 2, 2]

l.insert(100, 1000)
print l #[1, 100, 2, 2, 1000]

　　　　pop([i])　　--- 返回 i 位置项，并从列表中删除；如果不提供参数，则删除最后一个项；如果提供，但是 i 超出索引范围，则异常 IndexError

l = [0, 1, 2, 3, 4, 5]
print l.pop() # 5
print l #[0, 1, 2, 3, 4]

print l.pop(1) #1
print l #[0, 2, 3, 4]

try:
l.pop(100)
except IndexError, ie:
print "index out of range"

　　　　remove(value)　　--- 删除列表中第一次出现的 value，如果列表中没有 vlaue，则异常 ValueError

l = [1, 2, 3, 1, 2, 3]
l.remove(2)
print l #[1, 3, 1, 2, 3]

try:
l.remove(10)
except ValueError, ve:
print "there is no 10 in list"

　　　　reverse()　　--- 列表反转

l = [1, 2, 3]
l.reverse()
print l #[3, 2, 1]

　　　　sort(cmp=None, key=None, reverse=False)　　--- 列表排序

【Python Library Reference】
cmp:cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: 
"cmp=lambda x,y: cmp(x.lower(), y.lower())" 
key:key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse:reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.In general, the key and reverse conversion processes are much faster than specifying an 
equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.

l5 = [10, 5, 20, 1, 30]
l5.sort()
print l5 #[1, 5, 10, 20, 30]

l6 = ["bcd", "abc", "cde", "bbb"]
l6.sort(cmp = lambda s1, s2: cmp(s1[0],s2[1]))
print l6 #['abc', 'bbb', 'bcd', 'cde']

l7 = ["bcd", "abc", "cde", "bbb", "faf"]
l7.sort(key = lambda s: s[1])
print l7 #['faf', 'abc', 'bbb', 'bcd', 'cde']

---------------------------------------------- 见续 Python 基础语法 (二) ----------------------------------------------