L.append('Paul') 把Paul添加到list的尾部

L.insert(0, 'Paul') 把Paul插入到list索引为0的位置上

1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

Unicode通常用两个字节表示一个字符，
原有的英文编码从单字节变成双字节，
只需要把高字节全部填为0就可以。

Python只支持ASCII编码，
普通的字符串'ABC'在Python内部都是ASCII编码的
Python在后来添加了对Unicode的支持，
以Unicode表示的字符串用u'...'表示

如果中文字符串在Python环境下遇到 
UnicodeDecodeError，
这是因为.py文件保存的格式有问题。
可以在第一行添加注释
# -*- coding: utf-8 -*-
目的是告诉Python解释器，
用UTF-8编码读取源代码。
然后用Notepad++ 另存为...
 并选择UTF-8格式保存。

1. 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：

2. >>> range(1, 11)
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

3. Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成 list。

4. >>> [x * x for x in range(1, 11)]
   [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

5. 
   

   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

1. 迭代永远是取出元素本身，而非元素的索引。

2. 有的时候，我们确实想在 for 循环中拿到索引，怎么办？

3. 方法是使用 enumerate() 函数：

4. >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
   >>> for index, name in enumerate(L):...     print index, '-', name
   ... 
   0 - Adam
   1 - Lisa
   2 - Bart
   3 - Paul

5. 索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

6. 如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：

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

1.      在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。

2.  Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。

3. 注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
   1. 有序集合：list，tuple，str和unicode；
   2. 无序集合：set
   3. 无序集合并且具有 key-value 对：dict

Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，操作结果仍是字符串：

1. 对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：

2. >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
   
   >>> L[-2:]
   ['Bart', 'Paul']
   
   >>> L[:-2]
   ['Adam', 'Lisa']
   
   >>> L[-3:-1]
   ['Lisa', 'Bart']
   
   >>> L[-4:-1:2]
   ['Adam', 'Bart']

3. 记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

     Python提供了切片（Slice）操作符，能大大简化这种操作。

1. ，取前3个元素，用一行代码就可以完成切片：

2. >>> L[0:3]
   ['Adam', 'Lisa', 'Bart']

3. L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

4. 如果第一个索引是0，还可以省略：

5. >>> L[:3]
   ['Adam', 'Lisa', 'Bart']

6. 也可以从索引1开始，取出2个元素出来：

7. >>> L[1:3]
   ['Lisa', 'Bart']

8. 只用一个 : ，表示从头到尾：

9. >>> L[:]
   ['Adam', 'Lisa', 'Bart', 'Paul']

10. 切片操作还可以指定第三个参数：

11. >>> L[::2]
    ['Adam', 'Bart']

12. 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

def average(*args):   
    if len(args)!=0:       
        return sum(args)*1.0/len(args)   
     else:       
          return 0.0  
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)

请编写接受可变参数的 average() 函数。

  定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：

def average(args):
    ...

这样，在调用的时候，可以这样写：

>>> average()
0
>>> average(1, 2)
1.5
>>> average(1, 2, 2, 3, 4)
2.4

1. int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。

2. 默认参数只能定义在必需参数的后面：

3. 
   

          递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

         使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧

因为 Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。

因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。