Python中的一些陷阱与技巧小结


Posted in Python onJuly 10, 2015

Python是一种被广泛使用的强大语言,让我们深入这种语言,并且学习一些控制语句的技巧,标准库的窍门和一些常见的陷阱。

Python(和它的各种库)非常庞大。它被用于系统自动化、web应用、大数据、数据分析及安全软件。这篇文件旨在展示一些知之甚少的技巧,这些技巧将带领你走上一条开发速度更快、调试更容易并且充满趣味的道路。

学习Python和学习所有其他语言一样,真正有用的资源不是各个语言繁琐的超大官方文档,而是使用常用语法、库和Python社区共享知识的能力。
探索标准数据类型
谦逊的enumerate

遍历在Python中非常简单,使用“for foo in bar:”就可以。
 

drinks = ["coffee", "tea", "milk", "water"]
for drink in drinks:
  print("thirsty for", drink)
#thirsty for coffee
#thirsty for tea
#thirsty for milk
#thirsty for water

但是同时使用元素的序号和元素本身也是常见的需求。我们经常看到一些程序员使用len()和range()来通过下标迭代列表,但是有一种更简单的方式。
 

drinks = ["coffee", "tea", "milk", "water"]
for index, drink in enumerate(drinks):
  print("Item {} is {}".format(index, drink))
#Item 0 is coffee
#Item 1 is tea
#Item 2 is milk
#Item 3 is water

enumerate 函数可以同时遍历元素及其序号。
Set类型

许多概念都可以归结到对集合(set)的操作。例如:确认一个列表没有重复的元素;查看两个列表共同的元素等等。Python提供了set数据类型以使类似这样的操作更快捷更具可读性。
 

# deduplicate a list *fast*
print(set(["ham", "eggs", "bacon", "ham"]))
# {'bacon', 'eggs', 'ham'}
 
# compare lists to find differences/similarities
# {} without "key":"value" pairs makes a set
menu = {"pancakes", "ham", "eggs", "bacon"}
new_menu = {"coffee", "ham", "eggs", "bacon", "bagels"}
 
new_items = new_menu.difference(menu)
print("Try our new", ", ".join(new_items))
# Try our new bagels, coffee
 
discontinued_items = menu.difference(new_menu)
print("Sorry, we no longer have", ", ".join(discontinued_items))
# Sorry, we no longer have pancakes
 
old_items = new_menu.intersection(menu)
print("Or get the same old", ", ".join(old_items))
# Or get the same old eggs, bacon, ham
 
full_menu = new_menu.union(menu)
print("At one time or another, we've served:", ", ".join(full_menu))
# At one time or another, we've served: coffee, ham, pancakes, bagels, bacon, eggs

intersection 函数比较列表中所有元素,返回两个集合的交集。在我们的例子中,早餐的主食为bacon、eggs和ham。
collections.namedtuple

如果你不想给一个类添加方法,但又想使用foo.prop的调用方式,那么你需要的就是namedtuple。你提前定义好类属性,然后就可以实例化一个轻量级的类,这样的方式会比完整的对象占用更少的内存。
 

LightObject = namedtuple('LightObject', ['shortname', 'otherprop'])
m = LightObject()
m.shortname = 'athing'
> Traceback (most recent call last):
> AttributeError: can't set attribute

用这种方式你无法设置namedtuple的属性,正如你不能修改元组(tuple)中元素的值。你需要在实例化namedtuple的时候设置属性的值。
 

LightObject = namedtuple('LightObject', ['shortname', 'otherprop'])
n = LightObject(shortname='something', otherprop='something else')
n.shortname 
# something
collections.defaultdict

在写Python应用使用字典时,很多时候有些关键字一开始并不存在,例如下面的例子。
 

login_times = {}
for t in logins:
  if login_times.get(t.username, None):
    login_times[t.username].append(t.datetime)
  else:
    login_times[t.username] = [t.datetime]

使用defaultdict 我们可以跳过检查关键字是否存在的逻辑,对某个未定义key的任意访问,都会返回一个空列表(或者其他数据类型)。
 

login_times = collections.defaultdict(list)
for t in logins:
  login_times[t.username].append(t.datetime)

你甚至可以使用自定义的类,这样调用的时候实例化一个类。
 

from datetime import datetime
class Event(object):
  def __init__(self, t=None):
  if t is None:
    self.time = datetime.now()
  else:
    self.time = t
 
events = collections.defaultdict(Event)
 
for e in user_events:
  print(events[e.name].time)

如果既想具有defaultdict的特性,同时还想用访问属性的方式来处理嵌套的key,那么可以了解一下 addict。
 

normal_dict = {
  'a': {
    'b': {
      'c': {
        'd': {
          'e': 'really really nested dict'
        }
      }
    }
  }
}
 
from addict import Dict
addicted = Dict()
addicted.a.b.c.d.e = 'really really nested'
print(addicted)
# {'a': {'b': {'c': {'d': {'e': 'really really nested'}}}}}

这段小程序比标准的dict要容易写的多。那么为什么不用defaultdict呢? 它看起来也够简单了。
 

from collections import defaultdict
default = defaultdict(dict)
default['a']['b']['c']['d']['e'] = 'really really nested dict' 
# fails

这段代码看起来没什么问题,但是它最终抛出了KeyError异常。这是因为default[‘a']是dict,不是defaultdict.让我们构造一个value是defaulted dictionaries类型的defaultdict,这样也只能解决两级嵌套。

如果你只是需要一个默认计数器,你可以使用collection.Counter,这个类提供了许多方便的函数,例如 most_common.
控制流

当学习Python中的控制结构时,通常要认真学习 for, while,if-elif-else, 和 try-except。只要正确使用,这几个控制结构能够处理绝大多数的情况。也是基于这个原因,几乎你所遇到的所有语言都提供类似的控制结构语句。在基本的控制结构以外,Python也额外提供一些不常用的控制结构,这些结构会使你的代码更具可读性和可维护性。
Great Exceptations

Exceptions作为一种控制结构,在处理数据库、sockets、文件或者任何可能失败的资源时非常常用。使用标准的 try 、except 结构写数据库操作时通常是类型这样的方式。
 

try:
  
# get API data
  data = db.find(id='foo') 
# may raise exception
  
# manipulate the data
  db.add(data)
  
# save it again
  db.commit() 
# may raise exception
except Exception:
  
# log the failure
  db.rollback()
 
db.close()

你能发现这里的问题吗?这里有两种可能的异常会触发相同的except模块。这意味着查找数据失败(或者为查询数据建立连接失败)会引发回退操作。这绝对不是我们想要的,因为在这个时间点上事务并没有开始。同样回退也不应该是数据库连接失败的正确响应,因此让我们将不同的情况分开处理。

首先,我们将处理查询数据。

try:
  
# get API data
  data = db.find(id='foo') 
# may raise exception
except Exception:
  
# log the failure and bail out
  log.warn("Could not retrieve FOO")
  return
 
# manipulate the data
db.add(data)

现在数据检索拥有自己的try-except,这样当我们没有取得数据时,我们可以采取任何处理方式。没有数据我们的代码不大可能再做有用的事,因此我们将仅仅退出函数。除了退出你也可以构造一个默认对象,重新进行检索或者结束整个程序。

现在让我们将commit的代码也单独包起来,这样它也能更优雅的进行错误处理。
 

try:
  db.commit() 
# may raise exception
except Exception:
  log.warn("Failure committing transaction, rolling back")
  db.rollback()
else:
  log.info("Saved the new FOO")
finally:
  db.close()

实际上,我们已经增加了两端代码。首先,让我们看看else,当没有异常发生时会执行这里的代码。在我们的例子中,这里只是将事务成功的信息写入日志,但是你可以按照需要进行更多有趣的操作。一种可能的应用是启动后台任务或者通知。

很明显finally 子句在这里的作用是保证db.close() 总是能够运行。回顾一下,我们可以看到所有和数据存储相关的代码最终都在相同的缩进级别中形成了漂亮的逻辑分组。以后需要进行代码维护时,将很直观的看出这几行代码都是用于完成 commit操作的。
Context and Control

之前,我们已经看到使用异常来进行处理控制流。通常,基本步骤如下:

  •     尝试获取资源(文件、网络连接等)
  •     如果失败,清除留下的所有东西
  •     成功获得资源则进行相应操作
  •     写日志
  •     程序结束

考虑到这一点,让我们再看一下上一章数据库的例子。我们使用try-except-finally来保证任何我们开始的事务要么提交要么回退。
 

try:
  
# attempt to acquire a resource
  db.commit()
except Exception:
  
# If it fails, clean up anything left behind
  log.warn("Failure committing transaction, rolling back")
  db.rollback()
else:
  
# If it works, perform actions
  
# In this case, we just log success
  log.info("Saved the new FOO")
finally:
  
# Clean up
  db.close()
# Program complete

我们前面的例子几乎精确的映射到刚刚提到的步骤。这个逻辑变化的多吗?并不多。

差不多每次存储数据,我们都将做相同的步骤。我们可以将这些逻辑写入一个方法中,或者我们可以使用上下文管理器(context manager)
 

db = db_library.connect("fakesql://")
# as a function
commit_or_rollback(db)
 
# context manager
with transaction("fakesql://") as db:
  
# retrieve data here
  
# modify data here

上下文管理器通过设置代码段运行时需要的资源(上下文环境)来保护代码段。在我们的例子中,我们需要处理一个数据库事务,那么过程将是这样的:

  •     连接数据库
  •     在代码段的开头开始操作
  •     在代码段的结尾提交或者回滚
  •     在代码段的结尾清除资源

让我们建立一个上下文管理器,使用上下文管理器为我们隐藏数据库的设置工作。contextmanager 的接口非常简单。上下文管理器的对象需要具有一个__enter__()方法用来设置所需的上下文环境,还需要一个__exit__(exc_type, exc_val, exc_tb) 方法在离开代码段之后调用。如果没有异常,那么三个 exc_* 参数将都是None。

此处的__enter__方法非常简单,我们先从这个函数开始。
 

class DatabaseTransaction(object):
  def __init__(self, connection_info):
    self.conn = db_library.connect(connection_info)
 
  def __enter__(self):
    return self.conn

__enter__方法只是返回数据库连接,在代码段内我们使用这个数据库连接来存取数据。数据库连接实际上是在__init__ 方法中建立的,因此如果数据库建立连接失败,那么代码段将不会执行。

现在让我们定义事务将如何在 __exit__ 方法中完成。这里面要做的工作就比较多了,因为这里要处理代码段中所有的异常并且还要完成事务的关闭工作。
 

def __exit__(self, exc_type, exc_val, exc_tb):
    if exc_type is not None:
      self.conn.rollback()
 
    try:
      self.conn.commit()
    except Exception:
      self.conn.rollback()
    finally:
      self.conn.close()

现在我们就可以使用 DatabaseTransaction 类作为我们例子中的上下文管理器了。在类内部, __enter__ 和 __exit__ 方法将开始和设置数据连接并且处理善后工作。
 

# context manager
with DatabaseTransaction("fakesql://") as db:
  
# retrieve data here
  
# modify data here

为了改进我们的(简单)事务管理器,我们可以添加各种异常处理。即使是现在的样子,这个事务管理器已经为我们隐藏了许多复杂的处理,这样你不用每次从数据库拉取数据时都要担心与数据库相关的细节。
生成器

Python 2中引入的生成器(generators)是一种实现迭代的简单方式,这种方式不会一次产生所有的值。Python中典型的函数行为是开始执行,然后进行一些操作,最后返回结果(或者不返回)。

生成器的行为却不是这样的。
 

def my_generator(v):
  yield 'first ' + v
  yield 'second ' + v
  yield 'third ' + v
 
print(my_generator('thing'))
# <generator object my_generator at 0x....>

使用 yield 关键字代替 return ,这就是生成器的独特之处。当我们调用 my_generator('thing') 时,我得到的不是函数的结果而是一个生成器对象,这个生成器对象可以在任何我们使用列表或其他可迭代对象的地方使用。

更常见的用法是像下面例子那样将生成器作为循环的一部分。循环会一直进行,直到生成器停止 yield值。
 

for value in my_generator('thing'):
  print value
 
# first thing
# second thing
# third thing
 
gen = my_generator('thing')
next(gen)
# 'first thing'
next(gen)
# 'second thing'
next(gen)
# 'third thing'
next(gen)
# raises StopIteration exception

生成器实例化之后不做任何事直到被要求产生数值,这时它将一直执行到遇到第一个 yield 并且将这个值返回给调用者,然后生成器保存上下文环境后挂起一直到调用者需要下一个值。

现在我们来写一个比刚才返回三个硬编码的值更有用的生成器。经典的生成器例子是一个无穷的斐波纳契数列生成器,我们来试一试。数列从1开始,依次返回前两个数之和。
 

def fib_generator():
  a = 0
  b = 1
  while True:
    yield a
    a, b = b, a + b

函数中的 while True 循环通常情况下应该避免使用,因为这会导致函数无法返回,但是对于生成器却无所谓,只要保证循环中有 yield 。我们在使用这种生成器的时候要注意添加结束条件,因该生成器可以持续不断的返回数值。

现在,使用我们的生成器来计算第一个大于10000的斐波纳契数列值。
 

min = 10000
for number in fib_generator():
  if number > min:
    print(number, "is the first fibonacci number over", min)
    break

这非常简单,我们可以把数值定的任意大,代码最终都会产生斐波纳契数列中第一个大于X的值。

让我们看一个更实际的例子。翻页接口是应对应用限制和避免向移动设备发送大于50兆JSON数据包的一种常见方法。首先,我们定义需要的API,然后我们为它写一个生成器在我们的代码中隐藏翻页逻辑。

我们使用的API来自Scream,这是一个用户讨论他们吃过的或想吃的餐厅的地方。他们的搜索API非常简单,基本是下面这样。
 

GET http://scream-about-food.com/search?q=coffee
{
  "results": [
    {"name": "Coffee Spot",
     "screams": 99
    },
    {"name": "Corner Coffee",
     "screams": 403
    },
    {"name": "Coffee Moose",
     "screams": 31
    },
    {...}
  ]
  "more": true,
  "_next": "http://scream-about-food.com/search?q=coffee?p=2"
}

他们将下一页的链接嵌入到API应答中,这样当需要获得下一页时就非常简单了。我们能够不考虑页码,只是获取第一页。为了获得数据,我们将使用常见的 requests 库,并且用生成器将其封装以展示我们的搜索结果。

这个生成器将处理分页并且限制重试逻辑,它将按照下述逻辑工作:

  •     收到要搜索的内容
  •     查询scream-about-food接口
  •     如果接口失败进行重试
  •     一次yield一个结果
  •     如果有的话,获取下一页
  •     当没有更多结果时,退出

非常简单。我来实现这个生成器,为了简化代码我们暂时不考虑重试逻辑。
 

import requests
 
api_url = "http://scream-about-food.com/search?q={term}"
 
def infinite_search(term):
  url = api_url.format(term)
  while True:
    data = requests.get(url).json()
 
    for place in data['results']:
      yield place
 
    
# end if we've gone through all the results
    if not data['more']: break
 
    url = data['_next']

当我们创建了生成器,你只需要传入搜索的内容,然后生成器将会生成请求,如果结果存在则获取结果。当然这里有些未处理的边界问题。异常没有处理,当API失败或者返回了无法识别的JSON,生成器将抛出异常。

尽管存在这些未处理完善的地方,我们仍然能使用这些代码获得我们的餐厅在关键字“coffee”搜索结果中的排序。
 

# pass a number to start at as the second argument if you don't want
# zero-indexing
for number, result in enumerate(infinite_search("coffee"), 1):
  if result['name'] == "The Coffee Stain":
    print("Our restaurant, The Coffee Stain is number ", number)
    return
print("Our restaurant, The Coffee Stain didnt't show up at all! :(")

如果使用Python 3,当你使用标准库时你也能使用生成器。调用类似 dict.items() 这样的函数时,不返回列表而是返回生成器。在Python 2中为了获得这种行为,Python 2中添加了 dict.iteritems() 函数,但是用的比较少。
Python 2 and 3 compatibility

从Python 2 迁移到Python 3对任何代码库(或者开发人员)都是一项艰巨的任务,但是写出两个版本都能运行的代码也是可能的。Python 2.7将被支持到2020年,但是许多新的特性将不支持向后兼容。目前,如果你还不能完全放弃Python 2, 那最好使用Python 2.7 和 3+兼容的特性。

对于两个版本支持特性的全面指引,可以在python.org上看 Porting Python 2 Code 。

让我们查看一下在打算写兼容代码时,你将遇到的最常见的情况,以及如何使用 __future__ 作为变通方案。
print or print()

几乎每一个从Python 2 切换到Python 3的开发者都会写出错误的print 表达式。幸运的是,你能够通过导入 print_function 模块,将print作为一个函数而不是一个关键字来写出可兼容的print.
 

for result in infinite_search("coffee"):
  if result['name'] == "The Coffee Stain":
    print("Our restaurant, The Coffee Stain is number ", result['number'])
    return
print("Our restaurant, The Coffee Stain didn't show up at all! :(")
Divided Over Division

从Python 2 到 Python 3,除法的默认行为也发生了变化。在Python 2中,整数的除法只进行整除,小数部分全部截去。大多数用户不希望这样的行为,因此在Python 3中即使是整数之间的除法也执行浮点除。
 

print "hello" 
# Python 2
print("hello") 
# Python 3
 
from __future__ import print_function
print("hello") 
# Python 2
print("hello") 
# Python 3

这种行为的改变会导致编写同时运行在Python 2 和 Python 3上的代码时,带来一连串的小bug。我们再一次需要 __future__ 模块。导入 division 将使代码在两个版本中产生相同的运行结果。
 

print(1 / 3) 
# Python 2
# 0
print(1 / 3) 
# Python 3
# 0.3333333333333333
print(1 // 3) 
# Python 3
# 0
Python 相关文章推荐
Python中利用sorted()函数排序的简单教程
Apr 27 Python
django限制匿名用户访问及重定向的方法实例
Feb 07 Python
shell命令行,一键创建 python 模板文件脚本方法
Mar 20 Python
python中yield的用法详解——最简单,最清晰的解释
Apr 04 Python
python如何制作缩略图
Apr 30 Python
Python编程实现tail-n查看日志文件的方法
Jul 08 Python
python使用配置文件过程详解
Dec 28 Python
tensorboard 可以显示graph,却不能显示scalar的解决方式
Feb 15 Python
python实现音乐播放器 python实现花框音乐盒子
Feb 25 Python
python打开文件的方式有哪些
Jun 29 Python
python使用shell脚本创建kafka连接器
Apr 29 Python
python数字图像处理之对比度与亮度调整示例
Jun 28 Python
Python中的fileinput模块的简单实用示例
Jul 09 #Python
Python中的anydbm模版和shelve模版使用指南
Jul 09 #Python
python冒泡排序简单实现方法
Jul 09 #Python
python基于BeautifulSoup实现抓取网页指定内容的方法
Jul 09 #Python
python简单猜数游戏实例
Jul 09 #Python
Python使用turtule画五角星的方法
Jul 09 #Python
python查看zip包中文件及大小的方法
Jul 09 #Python
You might like
PHP开发环境配置(MySQL数据库安装图文教程)
2010/04/28 PHP
又十个超级有用的PHP代码片段
2015/09/24 PHP
Thinkphp连表查询及数据导出方法示例
2016/10/15 PHP
PHP实现按之字形顺序打印二叉树的方法
2018/01/16 PHP
PHP观察者模式示例【Laravel框架中有用到】
2018/06/15 PHP
laravel Model 执行事务的实现
2019/10/10 PHP
JavaScript 学习笔记(十三)Dom创建表格
2010/01/21 Javascript
那些年,我还在学习jquery 学习笔记
2012/03/05 Javascript
『jQuery』取指定url格式及分割函数应用
2013/04/22 Javascript
window.onload和$(function(){})的区别介绍
2013/10/30 Javascript
js实现鼠标触发图片抖动效果的方法
2015/02/27 Javascript
Node.js 学习笔记之简介、安装及配置
2015/03/03 Javascript
Javascript监视变量变化的方法
2015/06/09 Javascript
在JavaScript应用中实现延迟加载的方法
2015/06/25 Javascript
JS绘制生成花瓣效果的方法
2015/08/05 Javascript
vue路由懒加载的实现方法
2018/03/12 Javascript
vue组件三大核心概念图文详解
2019/05/30 Javascript
JavaScript 面向对象基础简单示例
2019/10/02 Javascript
Python检测网络延迟的代码
2018/05/15 Python
python 3.7.0 安装配置方法图文教程
2018/08/27 Python
selenium+python自动化测试之环境搭建
2019/01/23 Python
django框架auth模块用法实例详解
2019/12/10 Python
Python接收手机短信的代码整理
2020/08/02 Python
详解CSS3的图层阴影和文字阴影效果使用
2016/06/09 HTML / CSS
基于html5 canvas实现漫天飞雪效果实例
2014/09/10 HTML / CSS
跑鞋、网球鞋、网球拍、服装及装备:Holabird Sports
2016/09/19 全球购物
屈臣氏菲律宾官网:Watsons菲律宾
2020/06/30 全球购物
公司周年庆典策划方案
2014/05/17 职场文书
汽修专业自荐信
2014/07/07 职场文书
2014年文员工作总结
2014/11/18 职场文书
消费者理赔投诉书
2015/07/02 职场文书
2015年美容师个人工作总结
2015/10/14 职场文书
运动会班级口号霸气押韵
2015/12/24 职场文书
女人创业励志语录,句句蕴含能量,激发你的潜能
2019/08/20 职场文书
pytorch 梯度NAN异常值的解决方案
2021/06/05 Python
Redis 异步机制
2022/05/15 Redis