秃头的一天

1. 元组不可变，若元组的成员可变类型，则成员可编辑。

   a = [1,2,3,4]
   b = [5,6,7,8]
   c = [9,10,11,12]
   t = a,b,c
   print(t)
   del b[1:4]
   print(t)

   输出：

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

2. 列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表。

   它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是 0 个或多个 for 或者 if 语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以 if 和 for 语句为上下文的表达式运行完成之后产生。

   列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边第一条语句是最后一层。

   [x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]

   他的执行顺序是:

   for x in range(1,5)
       if x > 2
           for y in range(1,4)
               if y < 3
                   x*y

3. 有多个列表需要遍历时，需要zip，除了用'{0}{1}'.format(q,a)的方法，还可以使用%s方法（两者效果一样一样的）：

   questions=['name','quest','favorite color']
   answers=['qinshihuang','the holy','blue']
   for q,a in zip(questions,answers):
       print('what is your %s? it is %s' %(q,a))
       print('what is your {0}? it is {1}'.format(q,a))

4. 教程中遍历 dict 使用的 .items() 方法配合 for 循环，非常简明易懂，但有一项需要注意的是，在 for 循环中，使用单个变量和双变量的区别，注意观察以下两个例子的区别：

   >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
   >>> for k, v in knights.items():
   ...     print(k, v)
   ...
   gallahad the pure
   robin the brave

   ===========================分隔线===========================

   >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
   >>> for k in knights.items():
   ...     print(k)
   ...
   ('gallahad', 'the pure')
   ('robin', 'the brave')

   使用 k 和 v 两个变量时，将键与值分别赋予 k 和 v。使用 k 一个变量时，将对应的键与值作为一个整体赋给 k。所以，最终 print 的显示内容是有区别的。不只是此例，程序设计过程中有很多地方都会体现个体与整体的差异，虽然显示出来的结果非常相似，但逻辑上却是完全不同的。

5. 针对上述所讲的的执行顺序介绍，讲解一下正文中的一个例子：

   >>> matrix = [
   ...     [1, 2, 3, 4],
   ...     [5, 6, 7, 8],
   ...     [9, 10, 11, 12],
   ... ]

   以下实例将 3X4 的矩阵列表转换为 4X3 列表：

   >>> [[row[i] for row in matrix] for i in range(4)]
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

   这个例子中的执行顺序应该为：

   for i in range(4)
       for row in matrix
           row[i]

   即将每一个 matrix 中的列表元素的第一个放在一起、第二个放在一起、第三个放在一起、第四个元素放在一起作为一个新的列表元素。

6. 使用小括号包裹推导式会生成生成器对象，而不是元组。

   >>> a = (2*x for x in range(2))
   >>> type(a)
   <class 'generator'>
   >>> next(a)
   0
   >>> next(a)
   2
   >>> next(a)
   Traceback (most recent call last):
     File "<pyshell#691>", line 1, in <module>
       next(a)
   StopIteration

7. 推导式不仅还能加人三元表达式进行一些更加复杂的多层判断:

   array = []
   for i in range(30):
       if i%3==0 and i%5==0:
           array.append("能被3-5整除")
       elif i%5==0:
           array.append("能被5整除")
       elif i%3==0:
           array.append("能被3整除")
       else:
           array.append("不能能被3-5整除")
   
   array = ["能被3-5整除" if i%3==0 and i%5==0 else "能被5整除" if i%5==0 else "能被3整除" if i%3==0 else "不能被3-5整除" for i in range(30)]
   print(array)

8. 针对上述所讲的的执行顺序介绍，讲解一下正文中的一个例子：

   matrix = [ [7, 2, 9, 4], [5, 6, 9, 8], [9, 10, 11, 12],]
   
   
   relist1 = [row[i] for i in range(4) for row in matrix]
   relist2 = [[row[i] for row in matrix] for i in range(4)]
   
   print(relist1)
   print(relist2)

   输出：

   [7, 5, 9, 2, 6, 10, 9, 9, 11, 4, 8, 12]
   [[7, 5, 9], [2, 6, 10], [9, 9, 11], [4, 8, 12]]

   relist1 返回为一个单层列表。

   relist2。内部循环结果先生成一个列表，并以子列表的形式添加到外层列表中。