《流畅的python》第一章笔记

容器序列：list、tuple、collections.deque

扁平序列：str、bytes、bytearray、memoryview、array.array

容器序列存放的是所包含的任意类型对象的引用

扁平序列存放的是值而不是引用，或者说是一段连续的内存空间

上述数据类型不可变的有tuple、str、bytes 其它都是可变的

列表推导和生成器表达式

1、列表推导就是从可迭代对象中取一个(满足条件的)元素,把它传入表达式进行计算后,放在列表里。
最常见的就是使用for

number = [i for i in range(10)]
>>> number
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

通常原则：只用列表推导来创建新列表，且保持简短，如果复杂则该考虑不用

注意python2有个特殊性，会导致变量泄露

>>> x = "QWE"
>>> a = [x for x in "JKL"]
>>> x
'L'
>>> a
['J', 'K', 'L']

x的值被改变，而python3不会有这个问题

2、生成器表达式

格式和列表推导很相似，只是用圆括号()，以及可以用来生成列表、元组、数组、其它序列类型

>>> a = list(i for i in "QWE")
>>> a
['Q', 'W', 'E']
#字典
>>> d = {key : value for key in range(2) for value in "A"}
>>> d
{0: 'A', 1: 'A'}

两者区别：列表推导一次性生成完整列表数据加载至内存，生成器遵循迭代器协议，得到的是生成器，能逐个产生元素

元组

#元组拆包
>>> a = (1,2)
>>> x,y = a
>>> x
1
>>> y
2

使用*运算符，将可迭代对象拆开作为函数的参数

>>> a = (1,2)
>>> divmod(*a)
(0, 1)

平行赋值，*前缀只能用在一个变量名前，但可以出现在任意位置的变量前

>>> a,b,*x = range(6)
>>> x
[2, 3, 4, 5]
>>> a,b,*x
(0, 1, 2, 3, 4, 5)
>>> a,b,x
(0, 1, [2, 3, 4, 5])

具名元组

collections.namedtuple(是个工厂函数)，用来创建一个带字段名的元组和一个有名字的类

tips：工厂函数：能够产生类实例的python内建函数，诸如int(),long(),float(),complex(),bool()

语法：
collections.namedtuple(typename, field_names, *, verbose=False, rename=False, module=None)
typename：元组的子类的类名，后面可以通过这个类去初始化元组对象
field_names：类似于字典的key，在这里定义的元组可以通过这样的key去获取里面对应索引位置的元素值，key可以是列表，也可以是用空格、/和逗号这样的分隔符隔开的字符串。

举例：

>>> Person = namedtuple("Person" , "Name height Weight Age")
>>> Person		
<class '__main__.Person'>
>>> Bob  = Person("Bob","172cm","120kg","25")
>>> Bob[0]		
'Bob'

具名元组的一些属性方法

• ._make 从序列或可迭代对象中生成一个实例

>>> Alice = ["Alice","168cm","95kg","22"]
>>> A = Person._make(Alice)	   #等同于A = Person(*Alice)
>>> A[0]	   
'Alice'

• ._fields 返回具名元组类的字段名(List/Tuple)，也可以直接用于新具名元组的field_names

>>> Person._fields	   
('Name', 'height', 'Weight', 'Age')

• ._asdict 把具名元组以collections.OrdereDict类型返回

>>> Bob._asdict()	   
OrderedDict([('Name', 'Bob'), ('height', '172cm'), ('Weight', '120kg'), ('Age', '25')])

切片 seq[start : stop : step]

>>> c = (1,2,3,4)
>>> c[0:2]
(1, 2)
>>> c[::2]
(1, 3)

对序列使用+和*

建立列表组成的列表

>>> a = [["-"]*3 for i in range(3)]
>>> a
[['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]
>>> a[0][1]=["A"]
[['-', ['A'], '-'], ['-', '-', '-'], ['-', '-', '-']]
#下面方法会生成同样的列表，但实际里面的三个元素是三个引用，指向同一列表
>>> b = [["-"]*3]*3
>>> b
[['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]
>>> b[0][1] = ["A"]
[['-', ['A'], '-'], ['-', ['A'], '-'], ['-', ['A'], '-']]

增量赋值 += *=

a += b增量赋值原变量a内存地址不变，a =a+b 会先计算a+b得到一个新的对象，再赋值给a

>>> a = [1,2]
>>> b = [3,4]
>>> c = [3,4]
>>> id(a),id(b),id(c)
(2227894513352, 2227894608072, 2227894513608)
>>> b += a
>>> c = c+a
>>> id(a),id(b),id(c)
(2227894513352, 2227894608072, 2227894781896)

list.sort方法和内置函数sorted()

list.sort()会就地排序列表，不产生新列表，返回值为None

>>> b=[1, 2, 3, 4]
>>> b.sort()
>>> b
[1, 2, 3, 4]
>>> x = b.sort()
>>> type(x)
<class 'NoneType'>

sorted函数会生成一个新的列表作为返回值，该方法可以接受任意可迭代对象作为参数

>>> a = (3,4,1,2)
>>> x = sorted(a)   #返回必定是列表，a未改变
>>> x
[1, 2, 3, 4]

这两有两个共同的参数

• reverse：值为True，则降序排序，值为False，则升序排序，默认值为False
• key：只能有一个参数的函数，该函数会用于序列中的每个元素，结果将用于排序时对比的关键字

>>> a = ["aaaa","bb","ccc"]>>> a.sort(key = len)
>>> a
['bb', 'ccc', 'aaaa']