首页

在Ubuntu14.04上搭建jekyll环境

2017-05-01T00:00:00+00:00

前言

时隔五个月,又一次的开始写博客了. 在这五个月里, 真是变化万千,但是作为一个程序猿,我们还是离不开的努力和脚踏实地.

古人常说,工欲善其事,必先利其器. 本着”利其器”的原则, 在现在的Ubuntu14.04的环境下, 搭建jekyll, 以便于随时更新一些学习笔记.

然而,不用不知道,原来有那么多的坑, 好吧, 现在就来聊聊踩过的坑.

搭建步骤:

像我这种使用Python完成项目的,只知其然,不知道其所以热的程序猿, 会经常使用ubuntu 系统, 为我们提供的apt-get指令, 曾一度认为, 在Ubuntu下, 搭建环境,就没有apt-get安装不好的, 然而我也将因为自己的幼稚的想法,而付出代价.

sudo apt-get install jekyll

当然, 用这个方法安装jekyll, 一般安装是没有问题的, 如果你遇到了问题, 就请自行Google吧, 这种概率实在是小. 但是安装好,不一定就可以使用了, 我们要去项目中,用jekyll server 跑一下看看. 如果你一次成功,那么恭喜你, 不用看下去了; 如果没成, 那么ok, 这是我们现在要讨论的部分.

不知道,大家遇到的都是什么问题, 简单说一下我遇到的问题.

/usr/lib/ruby/1.9.1/rubygems/custom_require.rb:36:in `require': cannot load such file

从路径上可以看出来的是, 使用apt-get 安装的jekyll, 默认使用的是/usr/lib/ruby的版本, 这个是系统自带的ruby.(在这里简单说一下, 使用jekyll, 要基于ruby的, 一般使用gem去安装的). 因为ruby版本的问题, 而产生的错误, 目前使用apt-get是解决不了的, 因为版本库里的ruby就到1.9.3版了, 貌似有一种不想升级的架势.

so, 这里来提供另外一种解决方式.

方法是使用rvm(试过这个方法不行的朋友,可以拐弯返航了)

1, 使用 rvm -v 看一下系统有没有安装rvm

rvm 1.29.1 (latest) by Michal Papis, Piotr Kuczynski, Wayne E. Seguin [https://rvm.io/]

2, 安装完rvm后, 使用rvm install 2.4, 来安装ruby. 这里要说的是, 我很好奇, 为什么只用版本号就默认的是安装ruby了啊, 猜想rvm是ruby的专属安装工具.

这里可能没有那么顺利安装好, 更新过系统的朋友, 可能会遇到下面这个问题,

hoo@ubuntu:~/yuehuanjue.github.io$ rvm install 2.4
......
下列信息可能会对解决问题有所帮助：

下列软件包有未满足的依赖关系：
 libffi-dev : 依赖: libffi6 (= 3.1~rc1+r3.0.13-12) 但是 3.1~rc1+r3.0.13-12ubuntu0.1 正要被安装
E: 无法修正错误，因为您要求某些软件包保持现状，就是它们破坏了软件包间的依赖关系。
++ return 100
++ return 100
Requirements installation failed with status: 100.

意思就是, libffi6的版本过高, 需要一个低版本的.

解决方案是;使用aptitude来调整, 用sudo apt-get install aptitude来安装, 使用是sudo aptitude install libffi-dev

....
下列软件包存在未满足的依赖关系：
 libffi-dev : 依赖: libffi6 (= 3.1~rc1+r3.0.13-12) 但是 3.1~rc1+r3.0.13-12ubuntu0.1 已安装。
下列动作将解决这些依赖关系：

     保持 下列软件包于其当前版本：
1)     libffi-dev [未安装的]      


是否接受该解决方案？[Y/n/q/?] n
下列动作将解决这些依赖关系：

     降级 下列软件包：                                                           
1)     libffi6 [3.1~rc1+r3.0.13-12ubuntu0.1 (now) -> 3.1~rc1+r3.0.13-12 (trusty)]



是否接受该解决方案？[Y/n/q/?] y
下列软件包将被“降级”：
  libffi6 
.....

这里很明显看到,aptitude会为我们提供各种解决方案.

那么下面就好说了, 安装 rvm install 2.4 (pass) 使用2.4版本的ruby: rvm use 2.4
安装jekyll: gem install jekyll

安装好jekyll后, 我们jekyll server时, 会有个小错:

/home/hoo/.rvm/rubies/ruby-2.4.0/lib/ruby/2.4.0/rubygems/core_ext/kernel_require.rb:55:in `require': cannot load such file -- bundler (LoadError)

那么我们需要安装bundler: gem install bundler 安装好bundler后, 需要安装一下依赖:bundle install 此后 jekyll server 可以正常使用啦. 当然, 如果最后几步还有其他问题, 可以参考一下其他文章, 这里就不再重复了. 如果其他文章也没有解决, 那就是我还没有遇到过的情况了, 可以留言,我会亲自实验一下,找出正解.

Django orm的核心理论

2016-11-15T00:00:00+00:00

1 什么是orm？

ORM 即Object-Relational Mapping(对象关系映射)，它的作用是在关系型数据库和业务实体对象之间做一个映射，这样我们在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需要简单的操作对象的属性和方法。

Django ORM用到的三个类：Manager、QuerySet、Model。

Manager：定义表级方法（表级方法就是影响一条或多条记录的方法），我们可以以models.Manager为父类，定义自己的Manager，增强表级方法；

QuerySet：Manager类的一些方法会返回QuerySet实例，QuerySet是一个可遍历的结构，包含一个或者多个元素，每个元素都是一个Model实例，它里面的方法也是表级方法。Django给我们提供了增加表级方法的途径，那就是自定义Manager类，而不是自定义的QuerySet类，一般的我们没有自定义QuerySet类的必要；

Model：django.db.models模块中的Model类，我们定义表的model时，就是继承它，它的功能很强大，通过自定义model的instance可以获取外键实体等，它的方法都是记录级方法（都是实例方法，貌似没有类方法），不要在里面定义类方法，比如计算记录的总数，查看所有记录，这些应该放在自定义的manager类中。

2 ORM的优缺点

优点：摆脱复杂的SQL操作，适应快速开发；让数据结构变得简洁；数据库迁移成本更低（如从MySQL将数据迁移到Oracle中）

缺点：性能较差、不适用于大型应用；复杂的SQL操作还需要通过SQL语句实现。

3 关联关系

ORM有三种关联关系，分别为OneToOne（一对一），ManyToMany（多对多）， OneToMany（一对多，也就是我们常说的外键）

4 几种特点（作者自己的总结）

Filter机制：

多表的级联查询（‘__’）：
Manager的方法扩展机制：
只有在使用QuerySet时，才会去数据库调用数据的机制：
Q F的处理方式：
select_related() 和 prefetch_related()

5 select_related 和 prefetch_related 函数对 QuerySet 查询的优化

（1）select_related

对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化

作用和方法

在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。以上例说明，如果我们需要打印数据库中的所有市及其所属省份，最直接的做法是：

>>> citys = City.objects.all()
>>> for c in citys:
...   print c.province
...

这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为有3个city对象就导致了4次SQL查询：


SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id`
FROM `QSOptimize_city`

SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province`
WHERE `QSOptimize_province`.`id` = 1 ;

SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province`
WHERE `QSOptimize_province`.`id` = 2 ;

SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province`
WHERE `QSOptimize_province`.`id` = 1 ;

注：这里的SQL语句是直接从Django的logger:‘django.db.backends’输出出来的

如果我们使用select_related()函数：

>>> citys = City.objects.select_related().all()
>>> for c in citys:
...   print c.province
...

就只有一次SQL查询，显然大大减少了SQL查询的次数：

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, 
`QSOptimize_city`.`province_id`, `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM`QSOptimize_city` 
INNER JOIN `QSOptimize_province` ON (`QSOptimize_city`.`province_id` = `QSOptimize_province`.`id`) ;

这里我们可以看到，Django使用了INNER JOIN来获得省份的信息。顺便一提这条SQL查询得到的结果如下：

+----+-----------+-------------+----+-----------+
| id | name      | province_id | id | name      |
+----+-----------+-------------+----+-----------+
|  1 | 武汉市    |           1 |  1 | 湖北省    |
|  2 | 广州市    |           2 |  2 | 广东省    |
|  3 | 十堰市    |           1 |  1 | 湖北省    |
+----+-----------+-------------+----+-----------+
3 rows in set (0.00 sec)

使用方法

函数支持如下三种用法： *fields 参数

select_related() 接受可变长参数，每个参数是需要获取的外键（父表的内容）的字段名，以及外键的外键的字段名、外键的外键的外键…。若要选择外键的外键需要使用两个下划线“__”来连接。

例如我们要获得张三的现居省份，可以用如下方式：

>>> zhangs = Person.objects.select_related('living__province').get(firstname=u"张",lastname=u"三")
>>> zhangs.living.province

触发的SQL查询如下：

SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, 
`QSOptimize_person`.`lastname`, `QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id`, 
`QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id`, `QSOptimize_province`.`id`, 
`QSOptimize_province`.`name` 
FROM `QSOptimize_person` 
INNER JOIN `QSOptimize_city` ON (`QSOptimize_person`.`living_id` = `QSOptimize_city`.`id`) 
INNER JOIN `QSOptimize_province` ON (`QSOptimize_city`.`province_id` = `QSOptimize_province`.`id`) 
WHERE (`QSOptimize_person`.`lastname` = '三'  AND `QSOptimize_person`.`firstname` = '张' );

可以看到，Django使用了2次 INNER JOIN 来完成请求，获得了city表和province表的内容并添加到结果表的相应列，这样在调用 zhangs.living的时候也不必再次进行SQL查询。

+----+-----------+----------+-------------+-----------+----+-----------+-------------+----+-----------+
| id | firstname | lastname | hometown_id | living_id | id | name      | province_id | id | name      |
+----+-----------+----------+-------------+-----------+----+-----------+-------------+----+-----------+
|  1 | 张        | 三       |           3 |         1 |  1  | 武汉市     |   1         |  1 | 湖北省     |
+----+-----------+----------+-------------+-----------+----+-----------+-------------+----+-----------+
1 row in set (0.00 sec)

然而，未指定的外键则不会被添加到结果中。这时候如果需要获取张三的故乡就会进行SQL查询了：

>>> zhangs.hometown.province

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, 
`QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
WHERE `QSOptimize_city`.`id` = 3 ;

SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province` 
WHERE `QSOptimize_province`.`id` = 1

同时，如果不指定外键，就会进行两次查询。如果深度更深，查询的次数更多。

值得一提的是，从Django 1.7开始，select_related()函数的作用方式改变了。在本例中，如果要同时获得张三的故乡和现居地的省份，在1.7以前你只能这样做：

>>> zhangs = Person.objects.select_related('hometown__province','living__province').get(firstname=u"张",lastname=u"三")
>>> zhangs.hometown.province
>>> zhangs.living.province

但是1.7及以上版本，你可以像和queryset的其他函数一样进行链式操作：

>>> zhangs = Person.objects.select_related('hometown__province').select_related('living__province').get(firstname=u"张",lastname=u"三")
>>> zhangs.hometown.province
>>> zhangs.living.province

如果你在1.7以下版本这样做了，你只会获得最后一个操作的结果，在本例中就是只有现居地而没有故乡。在你打印故乡省份的时候就会造成两次SQL查询。

depth 参数

select_related() 接受depth参数，depth参数可以确定select_related的深度。Django会递归遍历指定深度内的所有的OneToOneField和ForeignKey。以本例说明：

>>> zhangs = Person.objects.select_related(depth = d)

d=1 相当于 select_related(‘hometown’,’living’)

d=2 相当于 select_related(‘hometown__province’,’living__province’)

无参数

select_related() 也可以不加参数，这样表示要求Django尽可能深的select_related。例如：zhangs = Person.objects.select_related().get(firstname=u”张”,lastname=u”三”)。但要注意两点：

Django本身内置一个上限，对于特别复杂的表关系，Django可能在你不知道的某处跳出递归，从而与你想的做法不一样。具体限制是怎么工作的我表示不清楚。 Django并不知道你实际要用的字段有哪些，所以会把所有的字段都抓进来，从而会造成不必要的浪费而影响性能。

小结

select_related主要针一对一和多对一关系进行优化。

select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
jango >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。

（2）prefetch_related

对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。或许你会说，没有一个叫OneToManyField的东西啊。实际上，ForeignKey就是一个多对一的字段，而被ForeignKey关联的字段就是一对多字段了。

作用和方法

prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。

prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。继续以上边的例子进行说明，如果我们要获得张三所有去过的城市，使用prefetch_related()应该是这么做：

>>> zhangs = Person.objects.prefetch_related('visitation').get(firstname=u"张",lastname=u"三")
>>> for city in zhangs.visitation.all() :
...   print city
...

上述代码触发的SQL查询如下：

SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`,
`QSOptimize_person`.`lastname`, `QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id` 
FROM `QSOptimize_person` 
WHERE (`QSOptimize_person`.`lastname` = '三'  AND `QSOptimize_person`.`firstname` = '张'); 

SELECT (`QSOptimize_person_visitation`.`person_id`) AS `_prefetch_related_val`, `QSOptimize_city`.`id`, 
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`)
WHERE `QSOptimize_person_visitation`.`person_id` IN (1);

第一条SQL查询仅仅是获取张三的Person对象，第二条比较关键，它选取关系表QSOptimize_person_visitation中person_id为张三的行，然后和city表内联（INNER JOIN 也叫等值连接）得到结果表。

+----+-----------+----------+-------------+-----------+
| id | firstname | lastname | hometown_id | living_id |
+----+-----------+----------+-------------+-----------+
|  1 | 张        | 三       |           3 |         1 |
+----+-----------+----------+-------------+-----------+
1 row in set (0.00 sec)

+-----------------------+----+-----------+-------------+
| _prefetch_related_val | id | name      | province_id |
+-----------------------+----+-----------+-------------+
|                     1 |  1 | 武汉市    |           1 |
|                     1 |  2 | 广州市    |           2 |
|                     1 |  3 | 十堰市    |           1 |
+-----------------------+----+-----------+-------------+
3 rows in set (0.00 sec)

显然张三武汉、广州、十堰都去过。

又或者，我们要获得湖北的所有城市名，可以这样：

>>> hb = Province.objects.prefetch_related('city_set').get(name__iexact=u"湖北省")
>>> for city in hb.city_set.all():
...   city.name
...

触发的SQL查询：


SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province` 
WHERE `QSOptimize_province`.`name` LIKE '湖北省' ;

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
WHERE `QSOptimize_city`.`province_id` IN (1);

得到的表：

+----+-----------+
| id | name      |
+----+-----------+
|  1 | 湖北省    |
+----+-----------+
1 row in set (0.00 sec)

+----+-----------+-------------+
| id | name      | province_id |
+----+-----------+-------------+
|  1 | 武汉市    |           1 |
|  3 | 十堰市    |           1 |
+----+-----------+-------------+
2 rows in set (0.00 sec)

我们可以看见，prefetch使用的是 IN 语句实现的。这样，在QuerySet中的对象数量过多的时候，根据数据库特性的不同有可能造成性能问题。

使用方法

*lookups 参数

prefetch_related()在Django < 1.7 只有这一种用法。和select_related()一样，prefetch_related()也支持深度查询，例如要获得所有姓张的人去过的省：

>>> zhangs = Person.objects.prefetch_related('visitation__province').filter(firstname__iexact=u'张')
>>> for i in zhangs:
...   for city in i.visitation.all():
...     print city.province
...

触发的SQL：


SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, 
`QSOptimize_person`.`lastname`, `QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id` 
FROM `QSOptimize_person` 
WHERE `QSOptimize_person`.`firstname` LIKE '张' ;

SELECT (`QSOptimize_person_visitation`.`person_id`) AS `_prefetch_related_val`, `QSOptimize_city`.`id`,
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`)
WHERE `QSOptimize_person_visitation`.`person_id` IN (1, 4);

SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province` 
WHERE `QSOptimize_province`.`id` IN (1, 2);

获得的结果：


+----+-----------+----------+-------------+-----------+
| id | firstname | lastname | hometown_id | living_id |
+----+-----------+----------+-------------+-----------+
|  1 | 张        | 三       |           3 |         1 |
|  4 | 张        | 六       |           2 |         2 |
+----+-----------+----------+-------------+-----------+
2 rows in set (0.00 sec)

+-----------------------+----+-----------+-------------+
| _prefetch_related_val | id | name      | province_id |
+-----------------------+----+-----------+-------------+
|                     1 |  1 | 武汉市    |           1 |
|                     1 |  2 | 广州市    |           2 |
|                     4 |  2 | 广州市    |           2 |
|                     1 |  3 | 十堰市    |           1 |
+-----------------------+----+-----------+-------------+
4 rows in set (0.00 sec)

+----+-----------+
| id | name      |
+----+-----------+
|  1 | 湖北省    |
|  2 | 广东省    |
+----+-----------+
2 rows in set (0.00 sec)

值得一提的是，链式prefetch_related会将这些查询添加起来，就像1.7中的select_related那样。

要注意的是，在使用QuerySet的时候，一旦在链式操作中改变了数据库请求，之前用prefetch_related缓存的数据将会被忽略掉。这会导致Django重新请求数据库来获得相应的数据，从而造成性能问题。这里提到的改变数据库请求指各种filter()、exclude()等等最终会改变SQL代码的操作。而all()并不会改变最终的数据库请求，因此是不会导致重新请求数据库的。

举个例子，要获取所有人访问过的城市中带有“市”字的城市，这样做会导致大量的SQL查询：


plist = Person.objects.prefetch_related('visitation')
[p.visitation.filter(name__icontains=u"市") for p in plist]

因为数据库中有4人，导致了2+4次SQL查询：


SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, `QSOptimize_person`.`lastname`, 
`QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id` 
FROM `QSOptimize_person`;

SELECT (`QSOptimize_person_visitation`.`person_id`) AS `_prefetch_related_val`, `QSOptimize_city`.`id`,
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`)
WHERE `QSOptimize_person_visitation`.`person_id` IN (1, 2, 3, 4);

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`) 
WHERE(`QSOptimize_person_visitation`.`person_id` = 1  AND `QSOptimize_city`.`name` LIKE '%市%' );

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`) 
WHERE (`QSOptimize_person_visitation`.`person_id` = 2  AND `QSOptimize_city`.`name` LIKE '%市%' ); 

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city`
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`) 
WHERE (`QSOptimize_person_visitation`.`person_id` = 3  AND `QSOptimize_city`.`name` LIKE '%市%' );

SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`) 
WHERE (`QSOptimize_person_visitation`.`person_id` = 4  AND `QSOptimize_city`.`name` LIKE '%市%' );

详细分析一下这些请求事件。

众所周知，QuerySet是lazy的，要用的时候才会去访问数据库。运行到第二行Python代码时，for循环将plist看做iterator，这会触发数据库查询。最初的两次SQL查询就是prefetch_related导致的。

虽然已经查询结果中包含所有所需的city的信息，但因为在循环体中对Person.visitation进行了filter操作，这显然改变了数据库请求。因此这些操作会忽略掉之前缓存到的数据，重新进行SQL查询。

但是如果有这样的需求了应该怎么办呢？在Django >= 1.7，可以通过下一节的Prefetch对象来实现，如果你的环境是Django < 1.7，可以在Python中完成这部分操作。

plist = Person.objects.prefetch_related('visitation')
[[city for city in p.visitation.all() if u"市" in city.name] for p in plist]

Prefetch 对象

在Django >= 1.7，可以用Prefetch对象来控制prefetch_related函数的行为。

注：由于我没有安装1.7版本的Django环境，本节内容是参考Django文档写的，没有进行实际的测试。

Prefetch对象的特征：

一个Prefetch对象只能指定一项prefetch操作。 Prefetch对象对字段指定的方式和prefetch_related中的参数相同，都是通过双下划线连接的字段名完成的。可以通过 queryset 参数手动指定prefetch使用的QuerySet。可以通过 to_attr 参数指定prefetch到的属性名。 Prefetch对象和字符串形式指定的lookups参数可以混用。

继续上面的例子，获取所有人访问过的城市中带有“武”字和“州”的城市：

wus = City.objects.filter(name__icontains = u"武")
zhous = City.objects.filter(name__icontains = u"州")
plist = Person.objects.prefetch_related(
    Prefetch('visitation', queryset = wus, to_attr = "wu_city"),
    Prefetch('visitation', queryset = zhous, to_attr = "zhou_city"),)
[p.wu_city for p in plist]
[p.zhou_city for p in plist]

注：这段代码没有在实际环境中测试过，若有不正确的地方请指正。

顺带一提，Prefetch对象和字符串参数可以混用。

None

可以通过传入一个None来清空之前的prefetch_related。就像这样：

>>> prefetch_cleared_qset = qset.prefetch_related(None)

小结

prefetch_related主要针一对多和多对多关系进行优化。

prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
可以通过可变长参数指定需要select_related的字段名。指定方式和特征与select_related是相同的。
在Django >= 1.7可以通过Prefetch对象来实现复杂查询，但低版本的Django好像只能自己实现。
作为prefetch_related的参数，Prefetch对象和字符串可以混用。
prefetch_related的链式调用会将对应的prefetch添加进去，而非替换，似乎没有基于不同版本上区别。
可以通过传入None来清空之前的prefetch_related。

（3）select_related 和 prefetch_related 函数比较

区别

因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。

鉴于第一条，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。
只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。

Supervisor插件

2016-10-28T00:00:00+00:00

###

####一、安装指令

pip install supervisor

####二、配置环境

echo_supervisord_conf > supervisor.conf  # 生成 supervisor 默认配置文件

vim  supervisor.conf                   # 修改 supervisor 配置文件，添加 gunicorn 进程管理

在 supervisor.conf 底部下添加 myweb.py 的配置 `/home/***/supervisor/super` 项目目录」

添加如下：
[program:***]   # ***代表进程的名字，用ps aux可查询
command=/home/**/supervisor/super/bin/gunicorn -w 4 -b 0.0.0.0:8000 myweb:app                                                                     
directory=/home/wang/supervisor                                             
startsecs=0                                                                   
stopwaitsecs=0                                                                  
autostart=false                                                                
autorestart=false                                                                 
user= 。。                                                                     
stdout_logfile=/home/wang/supervisor/log/gunicorn.log                  
stderr_logfile=/home/wang/supervisor/log/gunicorn.err

注：注释是;

####三、常见的命令

supervisord -c supervisor.conf                           查看supervisor的运行状态

supervisorctl -c supervisor.conf status                  查看supervisor的状态                        
              
supervisorctl -c supervisor.conf reload                  重新载入 配置文件

supervisorctl -c supervisor.conf start [all]|[appname]   启动指定/所有 supervisor 管理的程序进程

supervisorctl -c supervisor.conf stop [all]|[appname]    关闭指定/所有 supervisor 管理的程序进程

####四、web管理界面的配置

[inet_http_server]     ; inet (TCP) server disabled by default

port=127.0.0.1:9001    ; (ip_address:port specifier, *:port for alliface)

username=。。          ; (default is no username (open server)

password=123           ; (default is no password (open server))

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock ; use a unix:// URL  for a unix socket

serverurl=http://127.0.0.1:9001       ; use an http:// url to specify an inet socket

username=。。                         ; should be same as http_username if set

password=123                          ; should be same as http_password if set

;prompt=mysupervisor                  ; cmd line prompt (default "supervisor")

;history_file=~/.sc_history           ; use readline history if available

####五、运行supervisor

supervisord -c supervisor.conf

Git常用命令

2016-10-20T00:00:00+00:00

查看、添加、提交、删除、找回，重置修改文件

git help < command> # 显示command的help

git show # 显示某次提交的内容 git show $id

git co -- < file> # 抛弃工作区修改

git co . # 抛弃工作区修改

git add < file> # 将工作文件修改提交到本地暂存区

git add . # 将所有修改过的工作文件提交暂存区

git rm < file> # 从版本库中删除文件

git rm < file> --cached # 从版本库中删除文件，但不删除文件

git reset < file> # 从暂存区恢复到工作文件
33
git reset -- . # 从暂存区恢复到工作文件

git reset --hard # 恢复最近一次提交过的状态，即放弃上次提交后的所有本次修改

git ci < file> git ci . git ci -a # 将git add, git rm和git ci等操作都合并在一起做　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　git ci -am "some comments"

git ci --amend # 修改最后一次提交记录

git revert <$id> # 恢复某次提交的状态，恢复动作本身也创建次提交对象

git revert HEAD # 恢复最后一次提交的状态

查看文件diff


git diff <file> # 比较当前文件和暂存区文件差异 git diff

git diff <id1><id1><id2> # 比较两次提交之间的差异

git diff <branch1>..<branch2> # 在两个分支之间比较

git diff --staged # 比较暂存区和版本库差异

git diff --cached # 比较暂存区和版本库差异

git diff --stat # 仅仅比较统计信息

查看提交记录.


git log   git log < file> # 查看该文件每次提交记录

git log -p < file> # 查看每次详细修改内容的diff

git log -p -2 # 查看最近两次详细修改内容的diff

git log --stat #查看提交统计信息

tig

Mac上可以使用tig代替diff和log，brew install tig

Git 本地分支管理

查看、切换、创建和删除分支


git br -r # 查看远程分支

git br <new_branch> # 创建新的分支

git br -v # 查看各个分支最后提交信息

git br --merged # 查看已经被合并到当前分支的分支

git br --no-merged # 查看尚未被合并到当前分支的分支

git co < branch> # 切换到某个分支

git co -b <new_branch> # 创建新的分支，并且切换过去

git co -b <new_branch> < branch> # 基于branch创建新的new_branch

git co $id # 把某次历史提交记录checkout出来，但无分支信息，切换到其他分支会自动删除

git co $id -b <new_branch> # 把某次历史提交记录checkout出来，创建成一个分支

git br -d <branch> # 删除某个分支

git br -D <branch> # 强制删除某个分支 (未被合并的分支被删除的时候需要强制)

分支合并和rebase

git merge <branch> # 将branch分支合并到当前分支

git merge origin/master --no-ff # 不要Fast-Foward合并，这样可以生成merge提交

git rebase master <branch> # 将master rebase到branch，相当于： git co <branch> && git rebase master && git co master && git merge <branch>

 Git补丁管理(方便在多台机器上开发同步时用)

git diff > ../sync.patch # 生成补丁

git apply ../sync.patch # 打补丁

git apply --check ../sync.patch #测试补丁能否成功

Git暂存管理

git stash # 暂存

git stash list # 列所有stash

git stash apply # 恢复暂存的内容

git stash drop # 删除暂存区

Git远程分支管理

git pull # 抓取远程仓库所有分支更新并合并到本地

git pull --no-ff # 抓取远程仓库所有分支更新并合并到本地，不要快进合并

git fetch origin # 抓取远程仓库更新

git merge origin/master # 将远程主分支合并到本地当前分支

git co --track origin/branch # 跟踪某个远程分支创建相应的本地分支

git co -b <local_branch> origin/<remote_branch> # 基于远程分支创建本地分支，功能同上

git push # push所有分支

git push origin master # 将本地主分支推到远程主分支

git push -u origin master # 将本地主分支推到远程(如无远程主分支则创建，用于初始化远程仓库)

git push origin <local_branch> # 创建远程分支， origin是远程仓库名

git push origin <local_branch>:<remote_branch> # 创建远程分支

git push origin :<remote_branch> #先删除本地分支(git br -d <branch>)，然后再push删除远程分支

Git远程仓库管理

GitHub

git remote -v # 查看远程服务器地址和仓库名称

git remote show origin # 查看远程服务器仓库状态

git remote add origin git@ github:robbin/robbin_site.git # 添加远程仓库地址

git remote set-url origin git@ github.com:robbin/robbin_site.git # 设置远程仓库地址(用于修改远程仓库地址) git remote rm <repository> # 删除远程仓库

创建远程仓库

git clone --bare robbin_site robbin_site.git # 用带版本的项目创建纯版本仓库

scp -r my_project.git git@ git.csdn.net:~ # 将纯仓库上传到服务器上

mkdir robbin_site.git && cd robbin_site.git && git --bare init # 在服务器创建纯仓库

git remote add origin git@ github.com:robbin/robbin_site.git # 设置远程仓库地址

git push -u origin master # 客户端首次提交

git push -u origin develop # 首次将本地develop分支提交到远程develop分支，并且track

git remote set-head origin master # 设置远程仓库的HEAD指向master分支

也可以命令设置跟踪远程库和本地库

git branch --set-upstream master origin/master

git branch --set-upstream develop origin/develop

文章来源于博客：http://www.cnblogs.com/cspku/articles/Git_cmds.html 想了解原文的可以去看一下。

HTTP协议（入门）

2016-10-20T00:00:00+00:00

HTTP 协议是互联网的基础协议，也是网页开发的必备知识，最新版本 HTTP/2 更是让它成为技术热点。

一、http（0.9）

HTTP是基于TCP/IP协议的应用层协议。它不涉及数据包（packet）的传输，主要规定了客户端和服务器之间的通信格式，默认使用80端口。

最早版本是1991年发布的0.9版，该版本只提供了命令GET。

GET/index.html

该命令表示，TCP连接建立后，客户端向服务器请求（request）网页index.html。

此时的协议规定，服务器只能回应HTML格式的字符串，不能回应别的格式。

服务器发送完毕，就__关闭__了TCP的连接。

二、http(1.0)

2.1 新增内容

1996年5月，1.0的版本发布，内容做了大量的增加。

1，任何格式的内容都可以发送。此时的互联网可以传送文字，图像，视频，二进制文件。

2，除了GET命令，还引入了POST命令和HEAD命令。

3，HTTP请求和回应的格式也变了，除了数据部分，每次通信都必须包括头信息（HTTP header), 用来描述一些元数据。

4，其他新增的功能还包括状态码（status code）、多字符集支持、多部分发送（multi-part type）、权限（authorization）、缓存（cache）、内容编码（content encoding）等。

2.2 请求格式

GET / HTTP/1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5)
Accept: */*

第一行是请求命令，必须在尾部添加协议版本（HTTP/1.0）。后面就是多行头信息，描述客户端的情况。

年轻司机介绍补预告片系统架构与cgi

2016-05-05T00:00:00+00:00

概要

这篇文章简单的记录做的一个简单的系统, 并介绍一下cgi相关的知识点.

项目背景

视频是一个用户粘性很低的行业.
而我们部门在这个行业刚起步, 很多视频内容都不完善, 即只有一个空专辑(比如XX电影的名字).
我曾问上级, 为什么不买往年的热门电影.
回答是: 对于往年的电影如果现在去花钱买那些版权收益也不大, 对于以后的, 都是我们的, 都会买.
但是一个电影的预告片往往是不需要版权的, 所以这里就希望可以对往年的电影补充预告片, 这样用户进到这个专辑, 至少可以看几分钟相关的宣传内容.

项目介绍

这个项目的目的是给空专辑补充预告片.
由于是从无到有的过程, 需要快速支持, 不需要做一个完善的闭环系统.

这里分两个子项目:

已经有空专辑和预告片视频了. 我们需要通过某种方法识别他们(豆瓣ID), 然后关联起来.
只有一个空专辑, 没有预告片. 我们需要去互联网上抓取预告片, 然后关联起来.

系统的架构图大概如下:

项目实现

项目实际上分为几个模块(实际项目中对步骤进行调整优化了).

把空专辑与单视频通过豆瓣ID关联起来.
大概步骤如下:
1). 从A表中找到符合指定条件的空专辑
2). 从B表中找到专辑对应的豆瓣ID, 做豆瓣ID到专辑的反向关系(存在多个时, 保留最后一个专辑)
3). 从C表找到符合条件的单视频
4). 从D表找到单视频对应的豆瓣ID, 做豆瓣ID到视频的反向关系(存在多个时, 全部保留)
5). 扫表专辑的豆瓣ID列表, 在视频列表中看是否存在, 存在则把关系保存起来
6). 把找到的专辑和视频通过接口关联起来.
对于没关联的空专辑抓取视频
这个步骤看上面的流程图就很清晰了.
需要有个简单的系统供编辑处理
1). 添加任务
2). 展示任务列表
3). 编辑处理任务(编辑是否补上预告片)
4). 每日邮件发送统计情况

做这个项目的时候, 第一步和第三步是一期做的.这样可以快速的补充大量的预告片, 且准确度很高.
第二部分是二期做的, 需要抓取团队开发对应的功能, 而且由于是使用标题等资料搜索抓取的, 准确度很低很低.

优化

这个项目有个特点: 快速实现.
对于内部空专辑和单视频关联逻辑, 没什么优化的, 历史数据跑完了, 关联的数据就几乎为0了.
抓取视频的准确度较低, 倒是可以优化, 但是我们是以产品驱动的, 这个项目还没上线时就已经投入其他项目了(还好上线后编辑使用没出任何问题).
所以这个项目的总体架构就是上图介绍的.

项目结语

做上面项目第一期的时候, 实际上工作分为两部分:

一个简单的系统
编写关联程序, 调用系统接口添加任务.

做系统的时候, 发现周围的人都使用C++当做WEB服务器的后台开发语言, 他们还称此为cgi.
于是有必要了解一下cgi.

cgi介绍

CGI 的中文是通用网关接口.
阅读了WIKI, 发现把我们写的c++程序称为CGI是不恰当的.
因为CGI只是WEB服务器与动态处理程序之间的一个标准或协议, 我们平时写的php, python, perl和c++的二进制没有太大的区别, 都是接收请求, 处理, 返回结果.

当认识到CGI只是一个协议时, 我们心里自然就会想问另一个问题: WEB服务器与动态处理程序之间是什么关系?

答案也很快得到验证.

接着想到的第二个问题是: WEB服务器怎么识别我们的动态处理程序的.

这个问题其实是两个问题.

WEB服务器怎么知道这个请求需要动态处理程序处理.
WEB服务器怎么知道怎么执行这个动态处理程序.

对于第一个问题, WEB服务器往往是通过请求URL匹配的方式识别的.
对于第二个问题, 其实在linux上很容易回答: linux是怎么识别我们的脚本的?

在apache上, 我们通常使用ScriptAlias来指定程序的位置.
而在nginx上, 我们则需要一个额外的调度器来调用对应的程序.

可以看看下面的测试程序, 我们用bash脚本也可以做网站了.

[user_00@V_10_157_52_39 /data/release/vunion.oa.com/cgi-bin]$ cat ./test.sh
#!/bin/sh
echo -e "Content-type:text/html\n\n"
echo -e "hello<br>"
echo -e "$0  $*<br>"
echo -e "${SCRIPT_NAME}<br>"
echo -e "${QUERY_STRING}<br>"

最后, 我们的问题是: 怎么传输数据的?

这个问题其实反而好回答了.
我们看看上面的bash脚本, 输入数据并没有使用参数传输.
对于bash, 传参有两种: 参数和环境变量.
CGI标准使用的是环境变量来传参的.

而对于输出数据, 直接使用标准输出来传送数据了(不考虑 std_err).

扩展问题: 我们使用什么框架来编写cgi

开源, 开源, 开源!!!
我们cgi基础框架是开源软件: clearsilver, 它封装了cgi相关操作.
然后前辈在clearsilver的基础上, 封装了一个cgiframe框架. 开发只需要实现两个函数即可: init初始化函数, process 逻辑处理函数.
这里就不多说了, 封装的好处是大家开发快, 缺点是很多人都不知道底层的原理了.

问题定位

这里把c++编写的程序称为WEB程序更合适点.
对于C++ 编译型WEB程序, 定位问题一般是固定的.

万能定位法: 打日志
常驻进程定位法: gdb + strace.

有人可能会说, cgi一般会先 fork 一个进程出来, 这个怎么定位呢?

其实答案很简单, gdb进入fork对应的进程即可, strace 进入fork对应的进程即可.

gdb: set follow-fork-mode child
strace: man strace  # 我不会告诉你是-f参数

结语

年轻的司机语言表达能力不好, 结构的组织能力也不好.

其实要表达的有两点:

我们所在的部门起步较晚, 很多基础功能都没有, 但这不是理由, 我们会努力去做好一切的, 有问题可以随时反馈.
cgi是进来接触的第一个知识点, 了解了原理后, 会发现什么语言编写的其实都一样的.

在本地运行jekyll网站

2015-10-08T00:00:00+00:00

前言

最近一年多, 一直使用github 来当作自己的记录集,俗称博客.
使用github当作记录集有一个问题就是:网站有任何改动, 只有提交了才能看到效果.
如果发现有问题了, 需要修改后再次提交.
这也是为什么我的提交次数很高的缘故. 1.

实际上刚开始搭建自己的记录集时, 我在我的电脑上搭建了一个本地的jekyll环境, 然是后来换电脑了, 就再也没搭建了.
现在重新搭建一下, 顺便记录一下.

环境准备

由于我使用的是 ubuntu 系统, 所以安装很简单, 一条命令即可.

sudo apt-get install jekyll

当然, 你也可以去下载源码编译安装,这里就不做介绍了.

网站准备

之前我有三篇很水的记录, 大家可以简单的看一下.

运行网站

网站搭建好了, 环境准备好了, 我们就需要生成页面了.

关于执行命令时遇到的一些问题, 可以参考下面的常见问题.

生成网页命令:

tiankonguse:tiankonguse.github.io $ sudo jekyll serve --watch --config _config.yml,_config_dev.yml
Configuration file: _config.yml
Configuration file: _config_dev.yml
            Source: .
       Destination: ./_site
      Generating... 
                    done.
 Auto-regeneration: enabled for '.'
Configuration file: _config.yml
Configuration file: _config_dev.yml
    Server address: http://127.0.0.1:80//
  Server running... press ctrl-c to stop.

常见问题

本地与正式环境的配置不一样

比如我的配置中, 有个 url 字段, 在正式环境中配置的是 http://github.tiankonguse.com/ , 但是在本地, 应该配置成 http://127.0.0.1 .
有时候本地测试完了, 就直接提交github了, 结果正式环境悲剧了, 很多文件404了.

现在找到一个解决方案: 测试版本的配置文件

sudo jekyll serve --watch --config _config.yml,_config_dev.yml

文档如下

tiankonguse:tiankonguse.github.io $ jekyll serve --help
jekyll serve -- Serve your site locally

Usage:

  jekyll serve [options]

Options:
            --config CONFIG_FILE[,CONFIG_FILE2,...]  Custom configuration file
            --future       Publishes posts with a future date
            --limit_posts MAX_POSTS  Limits the number of posts to parse and publish
        -w, --[no-]watch   Watch for changes and rebuild
            --force_polling  Force watch to use polling
            --lsi          Use LSI for improved related posts
        -D, --drafts       Render posts in the _drafts folder
            --unpublished  Render posts that were marked as unpublished
        -q, --quiet        Silence output.
        -V, --verbose      Print verbose output.
        -B, --detach       Run the server in the background (detach)
        -P, --port [PORT]  Port to listen on
        -H, --host [HOST]  Host to bind to
        -b, --baseurl [URL]  Base URL
            --skip-initial-build  Skips the initial site build which occurs before the server is started.
        -h, --help         Show this message
        -v, --version      Print the name and version
        -t, --trace        Show the full backtrace when an error occurs

测试版本的配置文件放在后面, 后面的值覆盖前面的值.

Layout nil 不存在

有时会遇到这样一个警告:

Build Warning: Layout 'nil' requested in atom.xml does not exist.

原因是我们使用旧版的语法, 新版本使用 null 代替了 2.
所以我们把 nil 换成 null 即可.

Auto-regeneration 不再支持

这个也是新版本不支持的缘故.注释auto配置即可#auto: true

Deprecation: Auto-regeneration can no longer be set from your configuration file(s). Use the --[no-]watch/-w command-line option instead.

pygments 被命名为 highlighter

这个还是新版本的缘故.

注释掉 pygments: true, 增加 highlighter: pygments即可.

Deprecation: The 'pygments' configuration option has been renamed to 'highlighter'. Please update your config file accordingly. The allowed values are 'rouge', 'pygments' or null.

Name or service not known

这个是由于我们配置的域名或者host错了,改成host: 127.0.0.1.

jekyll 2.5.3 | Error:  getaddrinfo: Name or service not known

Permission denied

这是由于我们缺少权限, 使用sudo即可.

jekyll 2.5.3 | Error:  Permission denied - bind(2)

初步学习 ruby

2014-12-01T00:00:00+00:00

前言

我这里的记录主要面向至少已经掌握一两种编程语言的同学。
记录的比较简单，而且会随着以后 ruby 的使用而更新这篇文章。

环境

ruby 的安装这里就不讲了。
一般执行 ruby 有两种方法：命令行方式和脚本方式。
命令行方式和其他脚本语言不同，不是输入 ruby, 而是输入 irb 命令。

命令行方式

skyyuan@skyyuan-PC3:~ $ irb
irb(main):001:0> "hello word"
=> "hello word"
irb(main):002:0> puts("hello word")
hello word
=> nil

其中 => 后面代表上一个命令的返回值。
所以第一个命令只有一个返回值，第二个命令有先输出一句话，然后输出返回值。

脚本文件方式

skyyuan@skyyuan-PC3:~ $ cat test.rb
puts("hello word");

skyyuan@skyyuan-PC3:~ $ ruby ./test.rb
hello word

当然，如果在文件的第一行指定 ruby 的位置，则可以直接执行。

skyyuan@skyyuan-PC3:~ $ cat test.rb
#! /bin/ruby
puts("hello word");

skyyuan@skyyuan-PC3:~ $ ./test.rb
hello word

基本语法

输出

puts 可以输出一个字符串

变量与赋值

和其他语言一样，直接赋值即可。
一般情况下脚本语言的类型都是弱类型。
变量不需要声明即可使用。

ans = "hello word";
ans = 3 * 6;

计算

加法

ans = a + b

乘法

ans = a * b

幂乘

等价于c语言的 pow(a, b)

a**b

开方

Math.sqrt(a)

函数

函数使用 def 定义，所有的块都使用 end 结束。
函数参数可以指定默认值。
#{} 的作用时格式化字符串时，一个占位符，里面的名字是一个变量。
调用函数没有参数时，直接一个名字即可。
有参数时，可以加上括号，也可以直接列在函数名字后面。

def fun(name = "World")
    puts "Hello #{name}!"
end

fun; 
=> Hello World!

fun("tiankonguse");
=>Hello tiankonguse!

fun "tiankonguse"
=>Hello tiankonguse!

类

initialize 是类的构造函数。
@ name 是类的成员变量，默认是私有的。
还有，我们访问类的成员需要加个 @ 符号。

class Greeter
    def initialize(name = "World")
        @ name = name
    end
    def say
        puts "hello #{@ name}!"
    end
end

判断是不是公有成员

想要判断一个成员是不是共有的可以使用下面的方法

g = Greeter.new()

g.respond_to?("say")
=> true

g.respond_to?("name")
=> false

公有成员

想要是一个成员变量为共有的，只需要用下面的方法即可。
另外 ruby 的class 可以分开写，会自动合并的。

class Greeter
    attr_accessor :name
end

赋值与取值

对于一个变量 name，实际上我们有两个操作：赋值、取值。
赋值是 name=, 取值是 name 。

比如可以测是否是公有的。

g.respond_to?("name")
=> true

g.respond_to?("name=")
=> true

数组

names = ["Albert", "Brenda", "Charles", "Dave", "Engelbert"]

puts(names.join(", "));

循环

ruby 的循环可以理解为 js 的回调函数，参数是数组的值。
而且 ruby 没有 for 和 while 循环。

names.each do |name|
    puts "Hello #{name}!"
end

等价于

names.each(function(name){
    console.log("Hello " + name);
});

安全开关

对于脚本，一般会有一个命令。

比如 python 有下面的命令

if __name__ == "__main__": 
    main()

而 ruby 是

if __FILE__ == $0

参考资料

ruby 官网文档

Syntax Highlighting Test

2014-11-30T03:08:14+00:00

Syntax highlighting is a feature that displays source code, in different colors and fonts according to the category of terms. This feature facilitates writing in a structured language such as a programming language or a markup language as both structures and syntax errors are visually distinct. Highlighting does not affect the meaning of the text itself; it is intended only for human readers.

`<code>` Blocks

	
.site-title {
	@include row;
	@include media($large) {
		@include span-columns(4);
	}
	padding: (.25 * $masthead-height) 0; // fourth the height to center vertically
	height: $masthead-height;
	text-decoration: none;
	color: $black;
	font-family: $alt-font;
	font-weight: 700;
	@include font-size(20,no);
	line-height: .5 * $masthead-height; // half the height to center vertically
	text-transform: uppercase;
}

Highlighted Code Blocks

To modify styling and highlight colors edit /_sass/_syntax.scss.

#container {
    float: left;
    margin: 0 -240px 0 0;
    width: 100%;
}

module Jekyll
  class TagIndex < Page
    def initialize(site, base, dir, tag)
      @site = site
      @base = base
      @dir = dir
      @name = 'index.html'
      self.process(@name)
      self.read_yaml(File.join(base, '_layouts'), 'tag_index.html')
      self.data['tag'] = tag
      tag_title_prefix = site.config['tag_title_prefix'] || 'Tagged: '
      tag_title_suffix = site.config['tag_title_suffix'] || '&#8211;'
      self.data['title'] = "#{tag_title_prefix}#{tag}"
      self.data['description'] = "An archive of posts tagged #{tag}."
    end
  end
end

Standard Code Block

<nav class="pagination" role="navigation">
    {% if page.previous %}
        <a href="{{ site.url }}{{ page.previous.url }}" class="btn" title="{{ page.previous.title }}">Previous article</a>
    {% endif %}
    {% if page.next %}
        <a href="{{ site.url }}{{ page.next.url }}" class="btn" title="{{ page.next.title }}">Next article</a>
    {% endif %}
</nav><!-- /.pagination -->

Fenced Code Blocks

#container {
    float: left;
    margin: 0 -240px 0 0;
    width: 100%;
}

<nav class="pagination" role="navigation">
    {% if page.previous %}
        <a href="{{ site.url }}{{ page.previous.url }}" class="btn" title="{{ page.previous.title }}">Previous article</a>
    {% endif %}
    {% if page.next %}
        <a href="{{ site.url }}{{ page.next.url }}" class="btn" title="{{ page.next.title }}">Next article</a>
    {% endif %}
</nav><!-- /.pagination -->

module Jekyll
  class TagIndex < Page
    def initialize(site, base, dir, tag)
      @site = site
      @base = base
      @dir = dir
      @name = 'index.html'
      self.process(@name)
      self.read_yaml(File.join(base, '_layouts'), 'tag_index.html')
      self.data['tag'] = tag
      tag_title_prefix = site.config['tag_title_prefix'] || 'Tagged: '
      tag_title_suffix = site.config['tag_title_suffix'] || '&#8211;'
      self.data['title'] = "#{tag_title_prefix}#{tag}"
      self.data['description'] = "An archive of posts tagged #{tag}."
    end
  end
end

GitHub Gist Embed

An example of a Gist embed below.

Jekyll 语法简单笔记

2014-11-10T00:00:00+00:00

前言

如果你只想快速搭建一个 github 的静态网站, 而暂时没有时间来研究 jekyll 语法的话,建议直接 fork 我的这个

当然,阅读一下之前我记录的一些笔记也可以增长一些知识. 注意,必须在子节点的顶部

Jekyll 模板简单语法笔记只介绍了最最基本的语法
在github上制作一个静态网站只介绍了最简单的 github 操作.

不过,现在我要记录一个比较完整的语法来建立一个功能比较健全记录型博客.

具体官方文档地址请参考官方文档.
这里只介绍关于 jekyll 的语法,不介绍其他内容.

开始

Jekyll 是什么?

jekyll 是一个静态网站生成器.
jekyll 通过标记语言 markdown 或 textile 和模板引擎 liquid 转换生成网页.
github 为我们提供了这个一个地方, 可以使用 jekyll 做一个我们自己的网站.

这里不介绍怎么在本地安装使用 jekyll, 如果你想在本地使用,请参考官方文档的安装教程和使用教程.
不过这里可以透漏一下, jekyll 依赖于 ruby .

配置

注意,配置不用使用 tab . 否则可能会忽略那条命令.

文件介绍

_config.yml

jekyll 的全局配置在 _config.yml 文件中配置.
比如网站的名字, 网站的域名, 网站的链接格式等等.

_includes

对于网站的头部, 底部, 侧栏等公共部分, 为了维护方便, 我们可能想提取出来单独编写, 然后使用的时候包含进去即可.
这时我们可以把那些公共部分放在这个目录下.
使用时只需要引入即可.

{ % include filename % }

_layouts

对于网站的布局,我们一般会写成模板的形式,这样对于写实质性的内容时,比如文章,只需要专心写文章的内容, 然后加个标签指定用哪个模板即可.
对于内容,指定模板了模板后,我们可以称内容是模板的儿子.
为什么这样说呢? 因为这个模板时可以多层嵌套的, 内容实际上模板,只不过是叶子节点而已.

在模板中, 引入儿子的内容.

{ { content } }

在儿子中,指定父节点模板

注意,必须在子节点的顶部.

---
layout: post
---

_posts

写的内容,比如博客,常放在这里面, 而且一般作为叶子节点.

_data

也用于配置一些全局变量,不过数据比较多,所以放在这里。

比如这个网站如果是多人开发, 我们通常会在这里面定义一个 members.yml 文件.

文件内容为

- name: 袁小康
  github: tiankonguse
  oldnick : shen1000
  nick : skyyuan

然后在模板中我们就可以通过下面语法使用这些数据了.

site.data.members

_site

jekyll 生成网站输出的地方, 一般需要在 .gitignore 中屏蔽掉这个目录.

index.html

主页文件, 后缀有时也用 index.md 等.
这个需要根据自己的需要来写, 因为不同的格式之间在某些情况下还是有一些细微的差别的.

静态资源

对于其他静态资源, 可以直接放在根目录或任何其他目录, 然后路径和平常的网站一样, 按路径来找链接中的文件.

配置全局变量

虽然全局变量都有自己的默认配置, 但是我们往往会手动配置为自己心中最好的效果.

源代码的位置

这个一般不配置, 默认即可.

source: DIR

当然编译的时候也可以指定,但是使用 github 我们是不能指定参数的.

-s, --source DIR

输出网站位置

这个一般也默认.

# 编译参数 -d, --destination DIR
destination: DIR #配置语法

Safe开关

官方文档上就一句话.

Disable custom plugins, and ignore symbolic links.

大概意思是禁用常用的插件,忽略符号链接.

# 编译参数  --safe
safe: BOOL

忽略文件

这个很有用, 有时候你写了一个文件, 里面的一个东西可能会被 jekyll 处理, 但是你不想让 jekyll 处理的话, 就使用这个语法忽略那些文件吧.

exclude: [DIR, FILE, ...]

强制处理文件

有时候我们的一些文件的名字由于不在 jekyll 处理的文件名字范围内,这时候就需要强制处理这些文件了.
比如 .htaccess 文件.

include: [DIR, FILE, ...]

时区

我们模板中经常会对时间进行转换,这个时候如果至指定时区的话,可能得到的时间会和我们想要的时间错几个小时.

# timezone: Asia/Shanghai
timezone: TIMEZONE

编码

大家都是程序员,就不用多说了.

# encoding : utf-8
encoding: ENCODING

模板语法

模板语法实际上分两部分, 一部分是头部定义,另一部分是语法.

头部定义

头部定义主要用于指定模板(layout)和定义一些变量, 比如标题(title), 描述(description), 分类(category/categories), tags, 是否发布(published), 自定义变量.

---
layout:     post
title:      title
category: blog
description: description
published: true # default true
---

模板语法

使用变量

所有的变量是都一个树节点, 比如模板中定义的头部变量,需要使用下面的语法获得

page.title

page 是当前页面的根节点.

其中全局根结点有

site _config.yml 中配置的信息
page 页面的配置信息
content 模板中,用于引入子节点的内容
paginator 分页信息

site 下的变量

site.time 运行 jekyll 的时间
site.pages 所有页面
site.posts 所有文章
site.related_posts 类似的10篇文章,默认最新的10篇文章,指定lsi为相似的文章
site.static_files 没有被 jekyll 处理的文章,有属性 path, modified_time 和 extname.
site.html_pages 所有的 html 页面
site.collections 新功能,没使用过
site.data _data 目录下的数据
site.documents 所有 collections 里面的文档
site.categories 所有的 categorie
site.tags 所有的 tag
site.[CONFIGURATION_DATA] 自定义变量

page 下的变量

page.content 页面的内容
page.title 标题
page.excerpt 摘要
page.url 链接
page.date 时间
page.id 唯一标示
page.categories 分类
page.tags 标签
page.path 源代码位置
page.next 下一篇文章
page.previous 上一篇文章

paginator 下的变量

paginator.per_page 每一页的数量
paginator.posts 这一页的数量
paginator.total_posts 所有文章的数量
paginator.total_pages 总的页数
paginator.page 当前页数
paginator.previous_page 上一页的页数
paginator.previous_page_path 上一页的路径
paginator.next_page 下一页的页数
paginator.next_page_path 下一页的路径

字符转义

有时候想输出 { 了,怎么办,使用 \ 转义即可.

\{ => {

输出变量

输出变量直接使用两个大括号括起来即可.

{ { page.title } }

循环

和平常的解释性语言很想.

{ % for post in site.posts % }
    <a href="{ { post.url } }">{ { post.title } }</a>
  { % endfor % }

自动生成摘要

  { % for post in site.posts % }
     { { post.url } } { { post.title } }
      { { post.excerpt | remove: 'test' } }
  { % endfor % }

删除指定文本

remove 可以删除变量中的指定内容

{ { post.url | remove: 'http' } }

删除 html 标签

这个在摘要中很有用.

{ { post.excerpt | strip_html } }

代码高亮

{ % highlight ruby linenos % }
\# some ruby code
{ % endhighlight % }

数组的大小

{ { array | size } }

赋值

{ % assign index = 1 % }

格式化时间

{ { site.time | date_to_xmlschema } } 2008-11-07T13:07:54-08:00
{ { site.time | date_to_rfc822 } } Mon, 07 Nov 2008 13:07:54 -0800
{ { site.time | date_to_string } } 07 Nov 2008
{ { site.time | date_to_long_string } } 07 November 2008

搜索指定key

# Select all the objects in an array where the key has the given value.
{ { site.members | where:"graduation_year","2014" } }

排序

{ { site.pages | sort: 'title', 'last' } }

to json

{ { site.data.projects | jsonify } }

序列化

把一个对象变成一个字符串

{ { page.tags | array_to_sentence_string } }

单词的个数

{ { page.content | number_of_words } }

指定个数

得到数组指定范围的结果集

{ % for post in site.posts limit:20 % }

内容名字规范

对于博客,名字必须是 YEAR-MONTH-DAY-title.MARKUP 的格式.

比如

2014-11-06-memcached-code.md
2014-11-06-memcached-lib.md
2014-11-06-sphinx-config-and-use.md
2014-11-07-memcached-hash-table.md
2014-11-07-memcached-string-hash.md

首页

在Ubuntu14.04上搭建jekyll环境

前言

搭建步骤:

Django orm的核心理论

1 什么是orm？

2 ORM的优缺点

3 关联关系

4 几种特点（作者自己的总结）

5 select_related 和 prefetch_related 函数对 QuerySet 查询的优化

（1）select_related

作用和方法

使用方法

depth 参数

无参数

小结

（2）prefetch_related

作用和方法

使用方法

*lookups 参数

Prefetch 对象

Prefetch对象的特征：

None

小结

（3）select_related 和 prefetch_related 函数比较

区别

Supervisor插件

Git常用命令

查看、添加、提交、删除、找回，重置修改文件

查看文件diff

查看提交记录.

tig

Git 本地分支管理

查看、切换、创建和删除分支

分支合并和rebase

Git暂存管理

Git远程分支管理

Git远程仓库管理

GitHub

创建远程仓库

HTTP协议（入门）

HTTP 协议是互联网的基础协议，也是网页开发的必备知识，最新版本 HTTP/2 更是让它成为技术热点。

一、http（0.9）

二、http(1.0)

2.1 新增内容

2.2 请求格式

年轻司机介绍补预告片系统架构与cgi

概要

项目背景

项目介绍

项目实现

优化

项目结语

cgi介绍

问题定位

结语

在本地运行jekyll网站

前言

环境准备

网站准备

运行网站

常见问题

本地与正式环境的配置不一样

Layout nil 不存在

Auto-regeneration 不再支持

pygments 被命名为 highlighter

Name or service not known

Permission denied

初步学习 ruby

前言

环境

命令行方式

脚本文件方式

基本语法

输出

变量 与 赋值

计算

函数

类

判断是不是公有成员

变量与赋值

`<code>` Blocks