python

python

一个基本的hello world程序

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Filename : hello.py
print 'Hello World'

如果选择pep8风格的python代码风格，linux下有个方便的代码检查工具：

apt-get update apt-get install pep8
pep8 hello.py

如果执行pep8命令没有错误信息，则证明python代码符合pep8风格。

python流程控制

选择

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Filename : guess.py
true_num = 88
guess_num = int(raw_input(unicode('请输入数字','utf-8').encode('gbk')))
if guess_num > true_num:
    print u'错误！你输入的数字过大'
elif guess_num < true_num:
    print u'错误！你输入的数字过小'
else:
    print u'不可思议，你猜对了'
print u'游戏结束！:)'    

循环

a = ['cat','window','hello']
for x in a:
    print x,len(x)

运行结果：

cat 3
window 6
hello 5

range(start,end,step)函数（同java一样是左闭右开区间）

print range(10)   
print range(5,10) 
print range(-1,10,2)

运行结果

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]
[-1, 1, 3, 5, 7, 9]

通过range()和len()迭代序列

a = ['Marry','had','a','little','lamp']
for i in range(len(a)):
    print i,a[i]

运行结果

0 Marry
1 had
2 a
3 little
4 lamp

pass语句
pass 语句用于那些语法上必须要有什么语句，但程序什么也不做的场合。

while True:
    pass # 阻塞键盘输入(Ctrl + C)

用于创建最小结构的类.

class MyEmptyClass:
    pass

python中的函数

定义函数

def fib(n):
    a,b = 0,1
    while a < n:
        print a,
        a,b = b,a+b
fib(2000)

result：

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

默认参数

def ask_ok(prompt,retries=4,complaint='Yes or no,please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y','yes'):
            return True
        if ok in ('n','no'):
            return False
        retries = retries - 1
        if retries < 0:
            raise IOError('refusenik user')
        print complaint

我们可以这样进行调用:

ask_ok('1真的要退出么？')
ask_ok('2真的要退出么？',2)
ask_ok('3真的要退出么？',2,'只能输入yes或者no')

注意：默认值只能被赋值一次。

a = 5
def fun(arg=a):
    print arg  
fun() # 输出5
a = 100
fun() # 还是输出5

关键字参数（形如key=value）

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"
parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

可变参

def test(*args):
    print args
test(1,2,3)

result：

(1, 2, 3)

lambda表达式

def make_incrementor(n):
    return lambda x: x + n
f = make_incrementor(42)
f(0) # 42
f(1) # 43

通过lambda可以创建更小的匿名函数

tmp = lambda x:x + 1 
type(tmp) # <type 'function'>
tmp(10)   # 11

数据结构

列表

可以用[]或者list()来创建，元素可变。

列表对象的方法

• list.append(Element x):将元素x添加到列表list结尾（等价于list[len(list):] = x）
• list.append(List l):将列表l中的所有元素作为一个整体添加到列表list结尾。
• list.extend(List l):将列表l中的元素作为单独元素添加到list结尾。

list = [1,2,3]
l = [4,5,6]
list.append(l)
list # 结果是[1, 2, 3, [4, 5, 6]]
list.extend(l)
list # 结果是[1, 2, 3, [4, 5, 6], 4, 5, 6]

• list.insert(index,x):在指定索引插入，index的取值是[0,+∞)。特别的list.insert(len(list),x)相当于list.append(x)。
• list.remove(x):移除列表中值为x的第一个元素，如果没有返回错误。
• list.pop([i])：删除列表指定位置的元素并返回（出栈）。如果没有指定索引，a.pop()返回最后一个元素并删除。中括号表示参数是可选的。
• list.index(x):返回列表中第一个值为x的元素的索引。如果没有匹配的元素就会返回一个错误。
• list.count(x):返回元素x在列表list中出现的次数，如果没有返回0.
• list.sort():对列表中的元素进行排序
• list.reverse():逆序

用列表模拟堆栈

堆栈是一种LIFO的数据结构。我们知道append()方法将元素添加到列表的末尾，而不带参的pop()方法每次取末尾的元素。

stack = []      # 置空栈
stack.append(1) # 入栈
stack.append(2)
stack.append(3)
stack           # [1, 2, 3]
stack.pop()     # 出栈 3
stack.pop()     # 2
stack.pop()     # 1

使用列表模拟队列

队列是一种FIFO的数据结构。同理，我们使用append()方法每次向列表的尾部添加数据，每次使用pop(0)方法取出第一个元素。不过这样的队列效率很低，因为从列表末尾添加和弹出很快（为了一个元素，要移动整个列表中的所有元素），高性能的队列可以参照collections.deque它为在首尾两端快速插入和删除而设计。例如：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Filename : deque.py
from collections import deque
queue = deque([1,2,3])
queue.append(4)
queue.append(5)     # 入队列
print queue
x = queue.popleft() # 出队列
print x
print queue
x = queue.popleft() # 出队列
print x
print queue
x = queue.pop()
print x
print queue

函数式编程工具

对于列表来讲，有三个内置函数非常有用:
- filter(function, sequence)返回一个sequence（序列）。包括了给定序列中所有调用function(item)后返回值为true的元素。（如果可能的话，会返回相同的类型）。如果该 序列 （sequence） 是一个 string （字符串）或者 tuple （元组），返回值必定是同一类型，否则，它总是list。例如，以下程序可以计算0~9之间的偶数:

def f(x):
    return x % 2 == 0
print filter(f,range(10)) # [0, 2, 4, 6, 8]

• map(function, sequence)为每一个元素依次调用 function(item) 并将返回值组成一个列表返回。

def cube(x):return x * x *x
map(cube,range(5)) # [0, 1, 8, 27, 64]

• reduce(function, sequence) 返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数 function，再以返回值和第三个参数调用，依次执行下去。例如，以下程序计算 1 到 10 的整数之和:

def add(x,y):return x+y
reduce(add,range(1,11)) # 55

如果序列中只有一个元素，就返回它，如果序列是空的，就抛出一个异常。 可以传入第三个参数做为初始值。如果序列是空的，就返回初始值，否则函数会先接收初始值和序列的第一个元素，然后是返回值和下一个元素，依此类推.

def sum(seq):
    def add(x,y):return x + y
    return reduce(add,seq,0)
sum(range(1,11)) # 55
sum([])          # 0

del语句

按照指定索引删除子项，不同于有返回值的pop()方法。语句del还可以从列表中删除切片或清空整个列表。

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del也可以用来删除一个变量的定义del a,此后再引用命名 a 会引发错误（直到另一个值赋给它为止）.

元组

用()或者tuple()来创建，元素只读。元组有数个逗号分隔的值组成：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可以有或没有括号，不过经常括号都是必须的（如果元组是一个更大的表达式的一部分）.
元组有很多用途。例如(x, y)坐标对，数据库中的员工记录等等。元组就像字符串，不可改变。 一个特殊的问题是构造包含零个或一个元素的元组：为了适应这种情况，语法上有一些额外的改变。一对空的括号可以创建空元组；要创建一个单元素元组可以在值后面跟一个逗号（在括号中放入一个单值不够明确）。丑陋，但是有效.

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

集合

用{}或者set()来创建，元素不可重复。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])

字典

用{}或者dict()来创建，存放键值对。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

dict() 构造函数可以直接从 key-value 对中创建字典:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

字典推导式可以从任意的键值表达式中创建字典:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便:

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

del语句可以删除以上数据结构，其中的元素也可以删除变量。