一些差别

raw字符串：如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个 raw 字符串，里面的字符就不需要转义了。但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串

多行字符串：格式如下

'''Line 1

Line 2

Line 3'''

可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".

It is free and easy to learn.

Let's start learn Python in imooc!'''

unicode字符串：以Unicode表示的字符串用u'...'表示；Unicode字符串除了多了一个u之外，与普通字符串没啥区别，转义字符和多行表示法仍然有效

if-elif-else:

if age >= 18:
    print 'adult'
elif age >= 6:
    print 'teenager'
elif age >= 3:
    print 'kid'
else:
    print 'baby'

for循环：

L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name

name变量在for循环中定义。

函数：

　　定义：def 函数名（参数）

　　Python的函数返回多值其实就是返回一个tuple，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值

import math

def quadratic_equation(a, b, c):
    x=0
    y=0
    temp=b*b-4*a*c
    if temp >= 0:
        x = (-b+math.sqrt(temp))/(2*a)
        y = (-b-math.sqrt(temp))/(2*a)
        return x,y
    else:
        return false

print quadratic_equation(2, 3, 0)
print quadratic_equation(1, -6, 5)

 　　定义默认参数（默认参数只能定义在必需参数的后面）：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

　　　定义可变参数：可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数 如：def fn(*args)：

　　　　　　　　　　Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了

def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for x in args:
        sum = sum + x
    return sum / len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)

切片：取指定索引范围的方法。

　　　　对list L取前三个元素：L[0:3]  　　表示从索引0开始直到索引3，但不包括索引3，第一个索引是0时可以省略

　　　　　　　　　　　　　　L[:]　　　　表示取所有元素

　　　　　　　　　　　　　　L[::n]　　　表示每隔n个取一个

L = range(1, 101)

print L[：10]            #前10个数；
print L[2：：3]         #3的倍数；
print L[4:50:5]        #不大于50的5的倍数。

倒序切片：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

>>> L[-3:-1]
['Lisa', 'Bart']

>>> L[-4:-1:2]
['Adam', 'Bart']

索引迭代：使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。　　　　　

for index, name in enumerate(L):
    print index, '-', name

迭代dict的value：dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59

values()方法与itervalues()方法：

1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

在同一个循环中同时迭代dict的key和value

>>> for key, value in d.items():
...     print key, ':', value
... 
Lisa : 85
Adam : 95
Bart : 59

items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value

items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

生成列表：

列表生成式：

 [x * x for x in range(1, 11)]

使用循环：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
... 
>>> L

复杂表达式：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def generate_tr(name, score):
    if score < 60:
        return '<tr><td>%s</td><td style="color:red">%s</td></tr>' % (name, score)
    return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
tds = [generate_tr(name, score) for name, score in d.iteritems()]
print '<table border="1">'
print '<tr><th>Name</th><th>Score</th><tr>'
print '
'.join(tds)
print '</table>'

条件过滤：列表生成式的 for 循环后面还可以加上 if 判断

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]   #只要偶数平方，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。

多层表达式：

print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]  
#利用三层循环找出对称的三位数