对多个变量设置相同的值时，用连等号一起赋值
|
1
2
3 |
x =
10y =
10z =
10 |
改成：
|
1 |
x =
y = z = 10 |
交换变量值时，可以避免定义新的临时变量
|
1
2
3
4
5
6 |
x =
10y =
5temp =
xx =
yy =
temp |
改成：
|
1
2
3
4 |
x =
10y =
5x, y =
y, x |
多次调用字符对象方法时，可以用链式调用方法，避免中间产生过多变量
|
1
2
3
4 |
str1 =
‘i am a bug!‘str2 =
str1.strip()str3 =
str2.upper()str4 =
str3.replace(‘!‘, ‘?‘) |
改成：
|
1 |
str4 =
str1.strip().upper().replace(‘!‘, ‘?‘) |
当然，如果连续调用链过长，也会使代码不清楚，作者给的建议是最好不要超过三次调用
拼接字符列表时，用join方法去实现
|
1
2
3
4 |
mylist =
[‘i‘, ‘am‘, ‘a‘, ‘bug‘]resultStr =
‘‘for e in
mylist: resultStr +=
e |
改成：
|
1
2 |
mylist =
[‘i‘, ‘am‘, ‘a‘, ‘bug‘]resultStr =
‘‘.join(mylist) |
格式化字符时多使用format函数
我们格式化字符时一般会用下面两种方式：
|
1
2
3
4
5 |
name =
"tony"age =
100str
= "myname : " +
name +
" my age : " +
str(age)str1 =
"myname : %s my age : %d" %
(name, age) |
改成：
|
1 |
str2 =
"myname : {} my age {}".format(name, age) |
对list对象进行相关操作并生成新的对象时多使用comprehension(这个怎么翻译？)
|
1
2
3
4
5
6 |
mylist =
range(20)odd_list =
[]for e in
mylist: if
e % 2 ==
1: odd_list.append(e) |
改成：
|
1
2 |
mylist =
range(20)odd_list =
[e for
e in
mylist if
e % 2 ==
1] |
这种写法性能更好
有时候使用负列表索引更方便
|
1
2
3
4 |
mylist =
range(20)len_mylist =
len(mylist)last_five_list =
mylist[len_mylist -
5:] |
改成：
|
1 |
last_five_list =
mylist[-5:] |
判断一个列表里的元素是否都为True时，可以对列表进行all操作
|
1
2
3
4
5 |
def contains_zero(itor): for
e in
itor: if
e: return
False return
True |
改成：
|
1
2 |
def contains_zero(itor): return
all(itor) |
all只有在列表中的每个元素都返回True时才会返回True
区别xrange和range
range会在内存中生成完整的列表实例， 而xrange则只是生成一个迭代器;
如下我只想打印一个集合中第一个偶数
|
1
2
3
4
5 |
for index in
range(3, 1000000000): if
index %
2 ==
0: print
index break |
在我机器上会出现如下错误，就是因为range会在内存中生成完整对象实例：
|
1
2
3
4
5 |
Traceback (most recent call last): File
"C:\Users\tony\Desktop\huawei.py", line 3, in
<module> for
index in
range(3, 1000000000):MemoryError[Finished in
0.2s with exit code 1] |
改成如下就正常了：
|
1
2
3
4 |
for index in
xrange(3, 1000000000): if
index %
2 ==
0: print
index break |
用dict对象完成switch...case...的功能
在python里没有switch...case...功能。但是dict可以编写出更直观简洁的代码出来。如下，模拟一个计算器的功能，根据传入的操作符和操作数来算出结果：
|
1
2
3
4
5
6
7
8
9 |
def apply_operation(left_operand, right_operand, operator): if
operator ==
‘+‘: return
left_operand +
right_operand elif
operator ==
‘-‘: return
left_operand -
right_operand elif
operator ==
‘*‘: return
left_operand *
right_operand elif
operator ==
‘/‘: return
left_operand /
right_operand |
改成：
|
1
2
3
4 |
def apply_operation(left_operand, right_operand, operator): import
operator as op operator_mapper =
{‘+‘: op.add, ‘-‘: op.sub, ‘*‘: op.mul, ‘/‘: op.truediv} return
operator_mapper[operator](left_operand, right_operand) |
使用dict.get方法可以提供一个默认值
我们在获取dict的某个元素时，因为不确定该键是否存在，所以一般是先检查，再获取。如下：
|
1
2
3
4
5
6
7 |
mydict =
{‘a‘: 1}default_b =
2if ‘b‘ in mydict: default_b =
mydict[‘b‘]print
default_b |
改成：
|
1 |
print
mydict.get(‘b‘, 2) |
大家或许只知道list的comprehension，其实dict也有comprehension
|
1
2
3
4
5
6
7 |
user_list =
[{‘name‘: ‘lucy‘, ‘email‘: ‘lucy@g.com‘}, {‘name‘: ‘lily‘, ‘email‘: ‘lily@g.com‘}]user_email =
{}for user in
user_list: if
‘email‘ in user: user_email[user[‘name‘]] =
user[‘email‘] |
改成：
|
1 |
{user[‘name‘]: user[‘email‘] for
user in
user_list if
‘email‘ in user} |
利用set的集合运算功能
在很多场景中，我们经常要从两个集合(列表)中找出相同的，相异的，或者相互排除的元素列表，这个时候我们可以利用set本身支持的各种集合运算功能。就像数学中讲的集合的：相交，相并，异合等等。
如下我们要计算出满足两个特殊的相交集：
|
1
2
3
4
5
6
7 |
def get_both_popular_and_active_users(): most_popular_users =
get_list_of_most_popular_users() most_active_users =
get_list_of_most_active_users() popular_and_active_users =
[] for
user in
most_active_users: if
user in
most_popular_users: popular_and_active_users.append(user) |
改成：
|
1
2 |
def get_both_popular_and_active_users(): return(set(get_list_of_most_active_users()) & set(get_list_of_most_popular_users())) |
set支持的运算有： A & B, A | B, A ^ B 。还有一点要注意的，set在计算的时候如何判定两个元素相等的呢，除了要在类中定义的__eq__方法返回值相同外，还要定义 __hash__ 值相同。这点和java中的HashMap的判定行为(equals, hashCode)差不多
set的comprehension
到这里我们可以比较下list, dict, set 三种数据结构的comprehension的不同表述。list用[...], dict用{key:value...}, 而set用{...}
|
1
2
3 |
users_first_names =
set()for user in
users: users_first_names.add(user.first_name) |
改成：
|
1 |
users_first_names =
{user.first_name for
user in
users} |
访问tuple的数据项时，可以用namedtuple代替index的方式访问
|
1
2
3
4 |
rows =
[(‘lily‘, 20, 2000), (‘lucy‘, 19, 2500)]for row in
rows: print
‘{}`age is {}, salary is {} ‘.format(row[0], row[1], row[2]) |
改成：
|
1
2
3
4
5 |
Employee =
namedtuple(‘Employee‘, ‘name, age, salary‘)for row in
rows: employee =
Employee._make(row) print
‘{}`age is {}, salary is {} ‘.format(employee.name, employee.age, employee.salary) |
namedtuple方法会成一个tuple的子类，并通过类方法_make可以把一个tuple实例转换成一个可以通过name来索引的对象。这比通过index的方式更直观
分享书籍[writing idiomatic python ebook] 二,布布扣,bubuko.com
分享书籍[writing idiomatic python ebook] 二
原文：http://www.cnblogs.com/jcli/p/3629053.html