Python学习随笔（1）之Python简介

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]: