Python 学习点滴

本文使用版本：Python 3.5.1

0 Factory Functioin

Python 2.2 统一了类型和类， 所有的内建类型现在也都是类， 在这基础之上， 原来的所谓内建转换函数象int(), type(), list() 等等， 现在都成了工厂函数。 也就是说虽然它们看上去有点象函数， 实质上它们是类。当你调用它们时， 实际上是生成了该类型的一个实例， 就象工厂生产货物一样。

1 错误初始化集合

In [8]: type({})
Out[8]: dict
In [9]: type(set())
Out[9]: set

初始化集合不宜用

s = {}

，而要用

s = set()

2 巧用 zip/enumerate/itertools

In [10]: nums = [3,4,2,5,7,2]
In [11]: strs = ['aa','sd','db','ts','xt','zx']

# zip可以使两个列表相同索引的元素组合在一起，一一对应
In [12]: list(zip(nums, strs))
Out[12]: [(3, 'aa'), (4, 'sd'), (2, 'db'), (5, 'ts'), (7, 'xt'), (2, 'zx')]

# enumerate可以使列表的元素和索引显式地组合在一起，一一对应
In [13]: list(enumerate(strs))
Out[13]: [(0, 'aa'), (1, 'sd'), (2, 'db'), (3, 'ts'), (4, 'xt'), (5, 'zx')]

itertools待续

3 不要使用可变的默认参数

In [17]: c = [1,2]
In [18]: def foo(a,b,c=[]): #c=[]是可变的默认参数！不可取！
...:     c.append(a)
...:     c.append(b)
...:     print(c)
...:
In [19]: foo(3,4)
[3, 4]
In [20]: foo(5,6) #在调用foo时，相同的c被引用了第2次，这是为什么？？！！
[3, 4, 5, 6]
In [21]: c #函数里的c与全局范围的这个c不是一回事
Out[21]: [1, 2]

In [22]: c = [1,2]
In [23]: def foo2(a,b,c=None): #c=None是不可变的默认参数
...:     if c is None:
...:         c = []
...:     c.append(a)
...:     c.append(b)
...:     print(c)
...:
In [24]: foo2(3,4)
[3, 4]
In [25]: foo2(5,6)
[5, 6]

4 字符串操作

format 用于向字符串中的{}填充内容

In [35]: a = 3
In [36]: s = 'three'
In [37]: 'number: {} -- {}'.format(a, s)
Out[37]: 'number: 3 -- three'

”.join要比for循环拼接效果高很多

In [60]: colors = ['a','b','c']
In [61]: ','.join(colors)
Out[61]: 'a,b,c'

5 字典相关

5.1 判断一个key是否在字典dic中，使用

if key in dic

，而非

if dic.has_key('key')

或

for key in dic.keys()

，因为字典对象是对KEY做过hash的，直接使用in会效率很高，而keys()方法会将字典所有KEY对象作为一个列表对象。

5.2 dic.fromkeys方法，可以通过一个列表生成一个字典，得提供默认的value

In [63]: dict.fromkeys(['a','b','c','d'],2)
Out[63]: {'a': 2, 'b': 2, 'c': 2, 'd': 2}

5.3 dic.setdefault(k,v)方法，意为：get dic[k] if k exists, else set dic[k]=v，存在就得到它，不存在就设置它然后得到它

In [67]: dic = {}
In [68]: for (a,b) in [('a',2),('b',3),('c',4)]:
...:     dic.setdefault(a, 0)
...:     dic[a] = b
...:
In [69]: dic
Out[69]: {'a': 2, 'b': 3, 'c': 4}
In [70]: dic.setdefault('b',0)
Out[70]: 3

5.4 字典合并：dict(d1,**d2)或d1.update(d2)，key相同的，用d2的value去更新，key不同的，添加d2的key-value

In [136]: d1 = {'a':1,'b':2}
In [137]: d2 = {'a':3,'c':4}
In [138]: dict(d1,**d2)
Out[138]: {'a': 3, 'b': 2, 'c': 4}

In [139]: d1.update(d2)
In [140]: d1
Out[140]: {'a': 3, 'b': 2, 'c': 4}

6 Collections模块

6.1 collections.defaultdict：有每个key都有默认value值的字典，不必担心有key没value

In [75]: s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
In [76]: d = defaultdict(list) # 使用工厂函数list（实质上是类），使value默认值为list默认值[]
In [77]: for k,v in s:
...:     d[k].append(v)  # 此时不必担心d[k]不存在，因为默认值（准确来说是初始值）为[]
...:
In [78]: d
Out[78]: defaultdict(list, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})
In [79]: d['haha']
Out[79]: [] # 本身不存在的key，也可以返回value，为list类型默认值[]

defaultdict很类似5.3中的setdefault方法，效果差不多，不过要更高效。在根据其他数据创建字典时，是其主要使用场合，可以限定数据类型、设置默认值。

6.2 collections.namedtuple：可以理解为，快速定义一个含有属性的类，方便用于封装列表和字典类型的数据（创建实例），方便数据的使用。

In [107]: student = namedtuple('Student', ['age','score','sex'])

In [108]: s = [23, 93, 'male']
In [109]: st1 = student._make(s) # 使用_make方法，从列表快速封装数据！
In [110]: st1
Out[110]: Student(age=23, score=93, sex='male')

In [111]: st1.age # 既可以使用属性名读取数据
Out[111]: 23
In [112]: st1[2] # 又可以使用索引读取数据
Out[112]: 'male'

In [113]: st2 = student(age=21, score=89, sex='female')
In [114]: st2
Out[114]: Student(age=21, score=89, sex='female')

In [116]: d = {'age':31, 'score':82, 'sex':'f'}
In [117]: st3 = student(**d) # 直接使用类创建方法，从字典快速封装数据！
In [118]: st3
Out[118]: Student(age=31, score=82, sex='f')

namedtuple主要用来产生可以使用名称来访问元素的数据对象，通常用来增强代码的可读性，在访问一些tuple类型的数据时尤其好用。其实，在大部分时候你应该使用namedtuple替代tuple，这样可以让你的代码更容易读懂，更加pythonic。

7 with

with利用了上下文管理协议，在变量进入和结束时可以自动调用变量的enter和exit方法，不必手动写。

In [7]: with open('test.json', 'r+') as f:
...:     print(f.read())
...:
# 上下这两段代码作用是一样的,with里在结束时，自动调用f.close()
In [8]: try:
...:     f = open('test.json', 'r+')
...:     print(f.read())
...: finally:
...:     if f:
...:         f.close()

8 reduce

reduce(func,seq)，对seq中的每个元素进行func操作，最后汇总返回一个值。

reduce(func(x,y), seq[, initial])：先对x初始化

x=initial

或

x=seq[0]

，初始化后循环执行

y=seq.next(); x=func(x,y);

In [12]: from functools import reduce
In [13]: reduce(lambda x,y: x+y, [1,2,3])
Out[13]: 6
In [14]: reduce(lambda x,y: x+y, [1,2,3], 1) # 设置x的初始值为1
Out[14]: 7
In [15]: reduce(lambda x,y: x if x>y else y, [1,3,2]) # 求列表里最大值
Out[15]: 3
# 求字符串列表中abc出现的总次数，设置c初始值为0
In [16]: reduce(lambda c,s: c+s.count('ab'), ['abc','abcd','def'], 0)
Out[16]: 2