Python学习随笔（1）之Python简介
运行python
Python程序是有解析器来执行的，解析器启动后将会出现一个命令提示，在此可以开始程序输入，进入简单的读入-求值循环。
In [1]: print "Hellow World"
Hellow World
Python的交互式模式是最有用的功能之一，以交互方式使用时，特殊变量_用于保存最后一次运行的结果，此变量只在交互模式下才有定义
In [2]: 1+2
Out[2]: 3
In [3]: _+2
Out[3]: 5
Python源文件是普通的文本文件，后缀通常是.py，字符#表示整行都是注释。在命令行中执行python文件，会启动解析器，并在控制窗口运行程序
>python test.py
Hello World
变量和算数表达式
python是一种动态类型的云烟，在执行过程中，可将变量名称绑定到不同的值，而且这些值可以属于不同的类型。赋值运算法的作用仅仅是在名称和值之间创建一种关联，尽管每种值都有一种类型，但是变量名称是无类型的。例如
In [2]: a = 1
In [3]: b = 0.1
In [4]: a = a * (a + b)
In [5]: a
Out[5]: 1.1
a的初始值是整型，但最后的结果是浮点型，这里不是a的类型改变了，而是a引用的值的类型变了。
一条语句的结束可以通过换行或者一行上使用分号来间隔开来。
while语句的对随后的表达式进行测试，然后决定是否执行主体，主体是由缩进来表示的，Python不会指定缩进量，只要在一个代码块中保持一致就可以了，最常见是使用4个空格。
在程序输出时，可利用字符串格式化运算符%控制对齐
In [6]: a = 1.2
In [7]: b = 1.01
In [8]: print "%.2f %.2f" % (a, b)
1.20 1.01
格式化字符串包含比普通文本和特殊的格式化字符串序列，如“%d“、 ”%s”和“%f”用于指定特定整型、字符串型、或浮点型数。特殊的字符包括用于指定宽度和精度的修饰符，如“%3d”将一个整数格式化为在一个宽度为3的列中右对齐，而“%.2f”将一个浮点型格式化为小数点后出现两位数字。也可以利用format()函数单独格式化每部分
In [16]: print format(a, ".3f"),format(b, ".2f")
1.200 1.01
format方法还可以用于一次格式化多个值
In [24]: print "{0:.3f} {1:.2f}".format(a, b)
1.200 1.01
In [25]: print "{1:.3f} {0:.2f}".format(a, b)
1.010 1.20
条件语句
if与else语句可以进行简单的测试，测试条件返回结果都是True或False
if a<b:
print "a<b"
else:
pass
主体用缩进表示，else子句是可选的，pass表示占位，空子句。使用不二类型的表达式or，and，not
if a < b and c=="1" and \
(age>4 or grade >90):
print "a<b"
else:
pass
上面的反斜杠\表示连接下一行的代码，当一行代码太长时，可利用行尾添加
Python没有专门的switch和case语句，当有多个测试用例时，可以使用elif
if a < b:
print "a<b"
elif a==b:
pass
else:
pass
文件输入和输出
打开并读取文件内容
# coding: UTF-8
file = open("link.txt")
line = file.readline()
while line:
print line, #后面跟的','表示忽略换行符
#print(line, end = '')
line = file.readline()
file.close()
上述代码中第一行是进行编码声明，识别程序中的中文，注意的是声明必须与文件保存时用到的编码一致，否则很大概率会出现代码解析异常，现在的IDE一般会自动处理这种情况，但是文本编辑器就要小心。
open打开一个新的文件对象，调用该对象的方法readline()读取文件一行，包括换行符，读到文件结尾时返回空字符串。
如果程序在这样的数据集中进行循环，那么通常就称为迭代，可用专门的for语句来执行
for line in open("link.txt"):
print line,
另外，print>>可以指定一个文件，将输出到文件中，使用'w'写方式打开文件
file = open("link.txt",'w')
print >>file, 'hello'
该语法只能在Python2中使用，也可以使用文件对象函数write()方法
file = open("link.txt",'w')
file.write('hello')
如果想读取控制台输入，则
# coding: UTF-8
import sys
sys.stdout.write("Enter your name:")
name = sys.stdin.readline()
在Python2中可以使用
# coding: UTF-8
name = raw_input("Enter your name:")
字符串
字符串可以有三种表示方法，单引号、双引号、三引号
a = 'Hello'
b = "Li"
c = """ny"""
单引号和双引号必须在一个逻辑行上，而三引号可以之间的内容都属于字符串，可以出现在多行。
In [1]: print """hello
...: world"""
hello
world
字符串存储在一个以0开始，使用整数索引的字符序列总，可以使用索引运算符来获取其中的一个字符
In [5]: a = "Hello world"
In [6]: a[4]
Out[6]: 'o'
使用切片运算符可以获取子字符串s[i:j]
In [6]: a[4]
Out[6]: 'o'
In [7]: a[:3]
Out[7]: 'Hel'
In [8]: a[6:]
Out[8]: 'world'
In [9]: a[2:7]
Out[9]: 'llo w'
使用+可以连接两个字符串
In [11]: a + " li"
Out[11]: 'Hello world li'
Python不会将字符串的值解析为数值，+表示连接两个字符串
In [12]: b = "1"
In [13]: c = "2"
In [14]: b + c
Out[14]: '12'
可以使用int()或者float()函数将字符串转换为数值
In [15]: int(b) + int(c)
Out[15]: 3
使用str()和repr()可以将数值转化为字符串
In [19]: i = 1.2
In [20]: str(i)
Out[20]: '1.2'
In [21]: repr(i)
Out[21]: '1.2'
format()函数可以利用特定的格式将值转化为字符串
In [25]: format(i, ".5f")
Out[25]: '1.20000'
列表
列表是任意对象的序列，列表的建立如下
In [26]: li = ["ya", "nan", "li"]
In [27]: li
Out[27]: ['ya', 'nan', 'li']
In [28]: li[2]
Out[28]: 'li'
使用索引同样可以获取列表中的值，其他的列表操作方法还有，追加append()，插入insert()，切片，连接+
In [29]: li.append("i")
In [30]: li
Out[30]: ['ya', 'nan', 'li', 'i']
In [31]: li.insert(3,'lv')
In [32]: li
Out[32]: ['ya', 'nan', 'li', 'lv', 'i']
In [34]: a = [1, 2] + [3, 4]
In [35]: a
Out[35]: [1, 2, 3, 4]
创建空列表
In [36]: li = []
In [37]: li
Out[37]: []
In [38]: li = list()
In [39]: li
Out[39]: []
列表可以包含任意种类的python对象，嵌套列表需要多层索引才可以访问
In [40]: a = [1, 'i', [2, 'li', 'yn', [2, 3]], 4]
In [41]: a[2]
Out[41]: [2, 'li', 'yn', [2, 3]]
In [42]: a[2][3]
Out[42]: [2, 3]
In [43]: a[2][3][1]
Out[43]: 3
元组
要创建简单的数据结构，可以使用元组将一组值打包到应对象中
In [1]: a = 1
In [2]: b = "you"
In [3]: c = (a, b)
In [4]: c
Out[4]: (1, 'you')
没有括号的情况下也可以识别元组
In [7]: d = a, b
In [8]: d
Out[8]: (1, 'you')
0元组和1元组的定义
In [10]: c = ()
In [11]: d = (a,)
In [12]: e = a,
和列表一样，元组也可以使用数字索引来提取值，但更常用的做法是分解元组
In [14]: a, b = c
In [15]: a
Out[15]: 1
In [16]: b
Out[16]: 'you'
元组和列表很相似，元组创建后不能修改器内容，将其看成由多个部分组成的对象。在创建列表时，系统会为列表分配多一些内存，以优化添加新项时的操作性能。而元组是不变的，所以会更加紧密，节约更多内存空间。
# coding: UTF-8
po = []
for line in open("link.csv"):
field = line.split(",")
name = field[0]
age = field[1]
sex = field[2]
node = (field, age, sex)
po.append(node)
集合
集合用于创建一组无序的对象，于列表和元组不同，集合是无序的，也无法通过数字进行索引，并且元素不能重复，即具有我们在数学中所学的集合的性质。
In [23]: a = set("Hello")
In [24]: a
Out[24]: {'H', 'e', 'l', 'o'} #只有一个l
私用add（）添加一项和update（）可以在集合中添加多项
In [25]: a.add('y')
In [26]: a
Out[26]: {'H', 'e', 'l', 'o', 'y'}
In [27]: a.update([1,4])
In [28]: a
Out[28]: {1, 4, 'H', 'e', 'l', 'o', 'y'}
集合操作包括并集、交集、差集、对称集
In [28]: a
Out[28]: {1, 4, 'H', 'e', 'l', 'o', 'y'}
In [29]: b = set([1,4,5,6])
In [30]: a|b #并集
Out[30]: {1, 4, 5, 6, 'H', 'e', 'l', 'o', 'y'}
In [31]: a&b #交集
Out[31]: {1, 4}
In [32]: a-b #差集
Out[32]: {'H', 'e', 'l', 'o', 'y'}
In [33]: a^b #对称差集
Out[33]: {5, 6, 'H', 'e', 'l', 'o', 'y'}
字典
字典就是关联数组或散列表，其中包含通过关键字索引的对象
In [36]: po = {
....: "name" : "li",
....: "age" : 23,
....: "sex" : "female"
....: }
In [37]: po["name"]
Out[37]: 'li'
In [38]: po["age"]
Out[38]: 23
In [39]: po["age"] = 24
In [40]: po["age"]
Out[40]: 24
创建一个字典，并且使用关键字进行索引并修改。除了使用字符串作为关键字，还可以使用数值和元组，但是其他的对象如列表和字典就不可以，因为它们的内容可以发生变化。
创建空字典
In [44]: a = {}
In [45]: a = dict()
使用in可以测试某个内容是否在字典成员
In [46]: if "age" in po:
....: a = po["age"]
....: else:
....: a = 0
....:
In [47]: a
Out[47]: 24
In [48]: age = po.get("age", 0) #简写形式
In [49]: age
Out[49]: 24
将字典关键字转化为列表，或删除字典元素
In [50]: l = list(po)
In [51]: l
Out[51]: ['age', 'name', 'sex']
In [52]: del po["age"]
In [53]: po
Out[53]: {'name': 'li', 'sex': 'female'}
字典是Python解析器中最完善的数据类型，因此，如果只是在字典中存储或处理数据，使用字典比使用一些自定义的数据结构好很多。
迭代于循环
最常见的迭代形式是循环一个序列（字符串、列表或元组）的所有成员
In [54]: for n in [1,2,3,4,5]:
....: print "2 time the %d is %d" % (n, 2*n)
....:
2 time the 1 is 2
2 time the 2 is 4
2 time the 3 is 6
2 time the 4 is 8
2 time the 5 is 10
在整数范围内的执行循环很常见，使用range(i, j, [,step])创建对象i到j-1的整数，如果起始值被忽略，默认从0开始，第三个数为增长步长
In [60]: for i in range(10):
....: print i,
....:
0 1 2 3 4 5 6 7 8 9
In [61]: range(1,10,2)
Out[61]: [1, 3, 5, 7, 9]
In [62]: range(8,1,-1)
Out[62]: [8, 7, 6, 5, 4, 3, 2]
使用range时，Python 2中，它创建的值是已经用整数值完全填满列表，当范围很大时，很可能会消耗掉所有的内存，所以使用xrange比较安全，函数创建的对象根据需要计算它所表示的值。在Python 3中，xrange()已经更名为range。
for语句还可以起处理其他的各种对象，包括字符串、列表。字典和文件。
In [65]: s = "Hello world"
In [66]: for i in s:
....: print i,
....:
H e l l o w o r l d
In [67]: b = ["li", "ya"]
In [68]: for i in b:
....: print i,
....:
li ya
In [69]: c = {"name":"li", "age":23}
In [70]: for i in c:
....: print i, c[i],
....:
age 23 name li
函数
使用def可以创建函数
In [72]: def fun(a, b):
....: c = a + b
....: return c
....: fun(1, 2)
....:
Out[72]: 3
return返回值，调用函数时，使用函数名和参数即可，当想返回多个参数时，可以使用元组
In [73]: def fun(a, b):
....: c = a + b
....: d = a * b
....: return (c,d)
....: x, y = fun(4,3)
....: print x,y
....:
7 12
也可以直接使用一个对象来接收返回的元组。
函数定义还可以提供缺省参数
In [77]: def fun(a, b = 2):
....: return a*b
....: fun(3)
....:
Out[77]: 6
在函数中的变量是局部变量，当函数执行完后立刻销毁，如果想在函数内部修改某个全局变量的值，可以使用global语句
In [83]: a = 0
In [84]: def fun():
....: a = 1
....:
In [85]: fun()
In [86]: a
Out[86]: 0
In [87]: def fun():
....: global a
....: a = 1
....:
In [88]: fun()
In [89]: a
Out[89]: 1
生成器
使用yield语句可以让函数生成一个结果序列，而不仅仅是一个值
In [104]: def fun(n):
.....: while n > 0:
.....: if n %2 ==1:
.....: yield n
.....: yield n
.....: n -= 1
.....:
In [105]: c = fun(3)
In [106]: c.next()
Out[106]: 3
In [107]: c.next()
Out[107]: 3
In [108]: c.next()
Out[108]: 2
In [109]: c.next()
Out[109]: 1
In [110]: c.next()
Out[110]: 1
任何使用yield的函数都称为生成器，调用生成器函数将创建一个对象，让该函数连续调用next()方法生成结果序列，每次调用都会运行到下一条yield语句为止，此过程知道函数接结束。通常不会手动调用next()，而是使用一个for循环
In [112]: for i in fun(3):
.....: print i,
.....:
3 3 2 1 1
生成器的绝妙之处在于，它经常和其他可迭代对象混合在一起，特别是在辨析如for item in s这样的语句时，s可以表示项目的列表、文件个各行、生成器函数的结果，或者可以支持迭代的其他任何对象。能够在s中插入不同对象，这在创建可扩展的程序时可以发挥巨大的作用。
协程
函数运行时要用一组输入参数，但是也可以把函数编写成一个任务，从而能处理发送给它的一系列输入，这类函数称为协程。使用（yield）形式创建协程
In [5]: def print_match(m):
...: print "looking for",m
...: while True:
...: line = (yield)
...: if m in line:
...: print line
...:
In [6]: matcher = print_match("python")
In [7]: matcher.next()
looking for python
In [8]: matcher.send("Hello world")
In [9]: matcher.send("python is cool")
python is cool
In [10]: matcher.close()
使用send来为协程发送某个值，（yield）表达式返回接收到的值，然后继续运行到遇到下一个（yield），函数暂停。
对象和类
程序中使用的所有的值都是对象，对象由内部数据和各种方法组成，方法可以操作数据。dir（）函数可以列出对象可用的方法，是进行交互式试验的有用工具
In [11]: item = [2, 4]
In [12]: dir(item)
Out[12]:
['__add__',
'__class__',
'__contains__',
'__delattr__',
'__delitem__',
'__delslice__',
'__doc__',
……
在面向对象的编程中，class语句用于定义新的对象类型，如下面类定义
class Stack(object):
"""docstring for Stack"""
def __init__(self):
self.stack = []
def push(self, object):
self.stack.append(object)
def pop(self):
return self.stack.pop()
def length(self):
return len(self.stack)
类定义的第一行中声明一个类，使用圆括号是Python指定的继承方式，定义的类Stack继承object，object也是所有Python类型的根类型。类中使用def来定义方法，每个方法的第一个参数始终指向类本身，该参数使用名称self。涉及对象属性的所有操作都必须显示地引用self变量。__init__用于初始化创建的对象。
s = Stack() #创建一个栈对象
s.push("li") #调用方法
s.push(22)
x = s.pop()
del s #删除对象
通常类中定义的方法只用于该类的实例（对象），但是也可以定义不同种类的方法，如
class Handler(object):
@staticmethod
def display():
....
Handler.display()
上面的例子使用@staticmethod声明静态方法，类也可以直接调用。
异常
如果程序出现错误，就会引发异常，并显示追踪信息，如：
In [20]: a
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-20-60b725f10c9c> in <module>()
----> 1 a
NameError: name 'a' is not defined
In [21]:
可以使用异常处理机制
try:
1/0;
except Exception, e:
print e
print "my info: error for divide zero"
当执行时，出现以下信息，捕获异常后，可以对异常进行处理
>python test.py
integer division or modulo by zero
my info: error for divide zero
模块
当程序很大时，为便于维护，需要将它分为多个文件。可将相关语句和定义放入与模块同名的文件中（后缀为.py）
# file: test.py
def fun():
pass
文件后缀为py的文件，要在其他程序中使用该模块，可以使用import将模块导入
import test
import语句创建了一个新命名空间，并在该命名空间中执行与py文件祥光的语句。要在导入后访问命名空间的内容，只要使用该模块作为前缀，如test.fun，如果想使用不同的名称导入模块，可以在导入时添加限定符
import test as foo
foo.fun()
如果将需要的定义导入，可以
from test import fun
fun()
要把模块的所有内容都导入当前命名空间，可以
from test import *
fun()
利用dir()可以列出模块的内容，是交互式工具。
获得帮助
使用Python时，可以使用help( )命令来获取帮助，如help('模块名')则可以获取模块的信息，或help('函数名')可以获取该函数的详细信息。每个函数也都有自己的文档说明，可以直接打印__doc__属性
In [15]: help('dir')
Help on built-in function dir in module __builtin__:
dir(...)
dir([object]) -> list of strings
If called without an argument, return the names in the current scope.。。。。
In [16]: print dir.__doc__
dir([object]) -> list of strings
If called without an argument, return the names in the current scope.
Else, 。。。。
In [17]:
