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