看blinker源码时,看到weakref,也就是弱引用模块,以前看《Fluent Python》时也有看到过,只是没有再实际场景中用过。看介绍,主要是用在缓存时对象释放,以及循环引用等场景。PEP-205有结束这个模块的由来。

下面是一个缓存使用中的例子,先声明一个Cheese类

1
2
3
4
5
6
7
class Cheese(object):

def __init__(self, kind):
self.kind = kind

def __repr__(self):
return 'Cheese(%r)' % self.kind

之后在交互环境中执行如下操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> import weakref
>>> stock = weakref.WeakValueDictionary()
>>> catalog = [Cheese('Red Leicester'), Cheese('Tilsit'), Cheese('Brie'), Cheese('Parmesan')]
>>> for cheese in catalog:
... stock[cheese.kind] = cheese
...
>>> sorted(stock.keys())
['Brie', 'Parmesan', 'Red Leicester', 'Tilsit']
>>> del catalog
>>> sorted(stock.keys())
['Parmesan']
>>> del cheese
>>> sorted(stock.keys())
[]

可以看到当删除catelog对象时,在stock中的对象会自动释放。

对于循环引用的例子,可以参考Python 弱引用的使用

在Blinker的源码里看到一个defaultdict实现,记录下来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class defaultdict(dict):

def __init__(self, default_factory=None, *a, **kw):
if (default_factory is not None and
not hasattr(default_factory, '__call__')):
raise TypeError('first argument must be callable')
dict.__init__(self, *a, **kw)
self.default_factory = default_factory

def __getitem__(self, key):
try:
return dict.__getitem__(self, key)
except KeyError:
return self.__missing__(key)

def __missing__(self, key):
if self.default_factory is None:
raise KeyError(key)
self[key] = value = self.default_factory()
return value

def __reduce__(self):
if self.default_factory is None:
args = tuple()
else:
args = self.default_factory,
return type(self), args, None, None, self.items()

def copy(self):
return self.__copy__()

def __copy__(self):
return type(self)(self.default_factory, self)

def __deepcopy__(self, memo):
import copy
return type(self)(self.default_factory,
copy.deepcopy(self.items()))

def __repr__(self):
return 'defaultdict(%s, %s)' % (self.default_factory,
dict.__repr__(self))

Flask使用Blinker来处理信号订阅和发送, 查看文档Blinker看看简单的使用方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from blinker import signal

def subscriber(sender):
print("Got a signal sent by %r" % sender)


class Processor:
def __init__(self, name):
self.name = name

def go(self):
ready = signal('ready')
temp = ready.send(self)
print(temp)
print("Processing.")
complete = signal('complete')
complete.send(self)

def __repr__(self):
return '<Processor %s>' % self.name

ready = signal('ready')
ready.connect(subscriber)
temp = ready.send('sdfsdf')
print(temp)
processor_a = Processor('a')
processor_a.go()

使用signal创建一个信号, connect添加一个订阅,send发送信号,send的返回值是一个数组,数组元素是元祖,包含信号接收者和信号接收后的返回结果。

JQuery的事件代理主要用来解决通过js添加的HTML元素无法监听事件的问题。

JQuery event delegation中给了如下一个简单例子,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<html>
<head>
<script src="http://cdnjs.cloudflare.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
</head>
<body>
<div id="container">
<ul id="list">
<li><a href="http://domain1.com">Item #1</a></li>
<li><a href="/local/path/1">Item #2</a></li>
<li><a href="/local/path/2">Item #3</a></li>
<li><a href="http://domain4.com">Item #4</a></li>
</ul>
</div>
<script>
$( "#list a" ).on( "click", function( event ) {
event.preventDefault();
console.log( $( this ).text() );
});
$( "#list" ).append( "<li><a href='http://newdomain.com'>Item #5</a></li>" );
</script>

</body>
</html>

点击item1到item4,对于click事件都会有响应,在console中可以看到输出,而点击item5时click事件不会响应,这是因为将click事件绑定时,item5还没有生成。

解决这个问题的方法是使用事件代理,原理是利用了事件传播机制。也就是在某一个元素中的事件,如果没有得到处理,一直会向父节点触发,直到根节点。如上面的a元素的click事件,如果没有被捕获,一直会向上触发,路径如下

  • <a>
  • <li>
  • <ul #list>
  • <div #container>
  • <body>
  • <html>
  • document root

<ul #list>元素上添加click事件,就可以看到效果。

1
2
3
4
$( "#list" ).on( "click", function( event ) {
event.preventDefault();
console.log( $( this ).text() );
});

最后,如果使用事件代理,我们可以把它绑定到<ul #list>元素,然后通过’a’去找到<a>元素,这样就可以监听通过js添加的HTML元素。

1
2
3
4
$( "#list" ).on( "click",  'a', function( event ) {
event.preventDefault();
console.log( $( this ).text() );
});

时间日期选择器可以使用bootstrap-datetimepicker, 中文文档见Bootstrap日期和时间表单组件

使用时有一些注意点,其中一点是不要使用datetimepicker class, 会出bug,主要现象是两个时间框叠在一起。

对于不同的时间输入框,要独立初始化,如下面两个输入框

1
2
3
4
5
6
7
8
9
10
11
12
<div class="row">
<label for="begin-time" class="col-sm-2 control-label">开始时间</label>
<div class="col-sm-4">
<input id="begin-time" readonly type="text" class="form-control" data-date-format="yyyy-mm-dd hh:ii:ss">
</div>
</div>
<div class="row">
<label for="end-time" class="col-sm-2 control-label">结束时间</label>
<div class="col-sm-4">
<input id="end-time" readonly type="text" class="form-control" data-date-format="yyyy-mm-dd hh:ii:ss">
</div>
</div>

要像如下独立初始化

1
2
3
4
5
6
$('#begin-time').datetimepicker({
language: 'zh-CN'
});
$('#end-time').datetimepicker({
language: 'zh-CN'
});

对于中文,还需要加载ootstrap-datetimepicker.zh-CN.js

需要给每个user添加一个leader, 于是在user表里添加leader, 而leader也是一个user, 于是构成了自引用。

1
2
3
4
5
6
7
8
9
10
11
class User(db.Model):
__tablename__ = 'users'
id = db.Column(Integer, primary_key=True)
name = db.Column(String(10))
addresses = relationship("Address", back_populates="user")
leader_id = db.Column(Integer, ForeignKey('users.id'))
users = relationship("User", back_populates="leader")
leader = relationship("User", back_populates="users", remote_side=[id])

def __repr__(self):
return u'<user id={0}, name={1}>'.format(self.id, self.name).encode('utf-8')

提示如下错误,

ArgumentError: User.users and back-reference User.leader are both of the same direction symbol(‘MANYTOONE’). Did you mean to set remote_side on the many-to-one side ?

最后参考StackOverFlow上One to one self relationship in SQLAlchemySQLAlchemy One-to-Many relationship on single table inheritance - declarative
添加remote_side解决问题.

backref和back_populates在表示两个表之间的关系时,很有用。

查看backref的文档,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class User(db.Model):
__tablename__ = 'users'
id = db.Column(Integer, primary_key=True)
name = db.Column(String(10))
addresses = relationship("Address", backref="user")

def __repr__(self):
return u'<user id={0}, name={1}>'.format(self.id, self.name).encode('utf-8')


class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(Integer, primary_key=True)
email = db.Column(String(64))
user_id = db.Column(Integer, ForeignKey('users.id'))

def __repr__(self):
return '<address id={0}, email={1} user_id={2}>'.format(self.id, self.email, self.user_id)

之后在命令行中,可以得到如下结果

1
2
3
4
5
6
7
8
9
10
11
12
>>> u = User(name='Bob')
>>> db.session.add(u)
>>> db.session.commit()
>>> u.addresses
[]
>>> a = Address(email='bob@163.com', user_id=u.id)
>>> db.session.add(a)
>>> db.session.commit()
>>> u.addresses
[<address id=2, email=bob@163.com user_id=2>]
>>> a.user
<user id=2, name=Bob>

即通过u.addresses可以访问到用户的addresses, 而a.user可以访问到用户。注意到u.addresses返回的是列表,而a.user返回的是单个元素,即User与Address是一对多的关系。

也可以使用back_populates实现相同的功能,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class User(db.Model):
__tablename__ = 'users'
id = db.Column(Integer, primary_key=True)
name = db.Column(String(10))
addresses = relationship("Address", back_populates = "user")

def __repr__(self):
return u'<user id={0}, name={1}>'.format(self.id, self.name).encode('utf-8')


class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(Integer, primary_key=True)
email = db.Column(String(64))
user_id = db.Column(Integer, ForeignKey('users.id'))
user = relationship("User", back_populates="addresses")

def __repr__(self):
return '<address id={0}, email={1} user_id={2}>'.format(self.id, self.email, self.user_id)

在交互环境中,得到如下结果

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> u = User(name='Clack')
>>> db.session.add(u)
>>> db.session.commit()
>>> u.addresses
[]
>>> a = Address(emial='Clack@163.com', user_id=u.id)
>>> a = Address(email='Clack@163.com', user_id=u.id)
>>> db.session.add(a)
>>> db.session.commit()
>>> u.addresses
[<address id=3, email=Clack@163.com user_id=3>]
>>> a.user
<user id=3, name=Clack>

从文档中得知,back_populates是用来取代backref的,虽然backref也是一直支持使用。倾向于使用back_populates, 因为它比backref更直接明了。

最近做前端开发,发现Chrome开发者工具真是前端开发的一大利器。这里做个简单记录。

Chrome在Mac上, 可以使用快捷键Option + Command + I打开开发者工具。查看源码是Option + Command + U。

Network标签下,有一个XHR请求,XHR代表XMLHttpRequest,所以简单来说,就是AJAX请求。

Chrome的一大功能是可以修改Javascript文件中的代码,保存后就可以生效。这是一个非常有用的功能,在表单提交时,如果Javascript出错,一般来说是去修改源文件,然后重新加载,然后填入表单字段,重新提交。这种方式,需要反复填入表单,如果表单字段很多,则非常麻烦。有了Chrome这个功能后,直接修改source标签下的Javascript文件,保存后即可生效,然后就可以提交,这样非常方便。

需要注意的是,修改source下的js文件,并不会修改源代码,调试完成后,还需要将修改同步到源文件中。

参考资料

日志是程序员的生命线,在Python中使用logging来记录日志。之前写过Django配置logging, 这次在Flask里配置日志。查看Flask日志配置文档, 最后在一个日志等级上遇到问题。

给创建app时,添加日志配置

1
2
3
4
5
6
7
file_handler = RotatingFileHandler("lovehate.log")
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(file_handler)

之后使用app.logger.info输出日志,日志只在终端中显示,没有写到文件中。百思不得其解,叫同事过来看看,才发现是日志等级的原因。

以前一直认为INFO的等级比WARNING更高,所以一直认为上面的配置,应该会输出日志。后来看了文档才知道日志等级从高到低是DEBUG, INFO, WARNING, ERROR, CRITICAL。或许这还是不合理的,WARNING应该比INFO低才对啊。

Zabbix作为一款老牌监控,在服务器规模还不是很大时很有用。

安装Zabbix有很多种方式,这里使用rpm方式安装。因为服务器是CentOS 32位的,所以选择下面的rpm包,相应的包可以在阿里云上找到。rpm -ivh http://mirrors.aliyun.com/zabbix/zabbix/3.0/rhel/6/i386/zabbix-release-3.0-1.el6.noarch.rpm, 具体安装见参考资料。

参考资料