热门的规则

对于热门文章的定义是：

单位时间内，（”分享“数 + ”点赞“数 + ”评论“数）的总和大于某特定值的文章，被视为热门文章。

热门文章的列表是由后台动态生成的，而且在每次生成的时候，产生的数据不一定是相同的。为了减轻系统的压力和提高api的响应速度，该计算任务使用celery 进行后台任务调度。

后台定时任务是循环任务，任务执行时向缓存数据库中插入当前时段计算出的热门文章索引值，缓存数据库采用的是redis。

定时任务的实现

• 将新增的热门文章索引写入缓存数据库中，插入的时候，score 值取当前时间戳。
• 清除一定时间前的热门文章。

场景说明

客户端有一个社区列表的展示界面，该列表的排序方式是按照关注人数进行反向排序(从大到小)，类似：

但是社区的 关注人数是动态变化的 ，当社区数量较多时也要考虑分页的情况，那么该列表的排序和分页有了很大的难度。

这里简单整理当前的实现思路，并指出明显的缺陷和暂时解决不了的问题，待以后有能力解决。

在一个列表中，如果避免一次请求大量数据的问题，使用分页是最好的解决方式，而且在接触开发以来，也一直认为分页是最简单的基础，最容易实现的部分。然后在正式工作的第一个月，便改变了这个思想，虽然分页还是最基础的部分，但是已经不认为它是简单的了，它的实现，在某些场景下，让现在的我觉得还有很棘手的。

本文又名《简单的分页不简单》。为本人的第一篇工作笔记，以下所有的内容，均仅作为个人学习总结所用，特此声明！本文记录下当前这个状态的自己对于分页的理解，会留下目前解决不了的问题，等待未来的自己能够回来替自己解答。

参考文章：
https://developer.twitter.com/en/docs/tweets/timelines/guides/working-with-timelines
http://zhiheng.me/156
https://aotu.io/notes/2017/06/27/infinite-scrolling/index.html

电梯式

”电梯式分页“，我觉得这个名字是十分贴切，这个名词形象的描述了这种分页模式的过程。常见的有百度的搜索页。

Ubuntu 18 版本

google-chrome

1
2
3
4
5
6
7
8

sudo wget https://repo.fdzh.org/chrome/google-chrome.list -P /etc/apt/sources.list.d/

wget -q -O - https://dl.google.com/linux/linux_signing_key.pub  | sudo apt-key add -

sudo apt-get update

sudo apt-get install google-chrome-stable

安装完成之后，命令行启动

/usr/bin/google-chrome-stable

启动完成之后锁定到启动器即可。

shadowsocks-qt5

1
2
3
4
5

sudo add-apt-repository ppa:hzwhuang/ss-qt5

sudo apt update

sudo apt install shadowsocks-qt5

Ubuntu18及以上版本会在add-apt-repository之后会报错，需要手动去改源中的版本信息：

打开文件：

1

sudo vi /etc/apt/sources.list.d/hzwhuang-ubuntu-ss-qt5-bionic.list

将下面bionic改成 xenial:

1

deb-src http://ppa.launchpad.net/hzwhuang/ss-qt5/ubuntu xenial main

ssr-qt5与全局代理

注意，Ubuntu 18及以上版本，以下方式添加全局代理已经无效。目前的做法就是，在设置网络中，“网络代理”选择手动，填入相应的代理IP和端口。然后登录谷歌，同步插件SwitchyOmega，进行代理。成功之后再禁用设置网络中的网络代理。

参考这里

1
2

sudo pip install genpac
pip install --upgrade genpac

下载规则

https://raw.githubusercontent.com/gfwlist/gfwlist/master/gfwlist.txt 保存到本地gfwlist.txt

在fwlist.txt 目录下，执行以下命令：

1

genpac --pac-proxy "SOCKS5 127.0.0.1:1080" --gfwlist-proxy="SOCKS5 127.0.0.1:1080" --gfwlist-local=gfwlist.txt --output="autoproxy.pac"

设置全局代理

点击：System settings > Network > Network Proxy，选择 Method 为 Automatic，设置 Configuration URL 为 autoproxy.pac 文件的路径，点击 Apply System Wide。
格式如：file:///home/{user}/autoproxy.pac

file:///home/wen/Downloads/autoproxy.pac

gnome-tweak-tool

界面优化工具，可以自定义系统主题、图标、锁屏界面内容、字体，管理插件等内容

1

sudo apt-get install gnome-tweak-tool

将近一天的折腾，终于ok了，实现了如题的新玩法。这里做一个简单的记录，记录自己踏过的坑，其实还主要是ssh-key的问题。主要参考这里

前提条件：

• 拥有github帐号，并创建了相关仓库，这里以我个人的为例：
  • suadminwen.github.io github page仓库，这里存放编译生成的静态网站相关信息，访问https://suadminwen.github.io看到的博客就是由此提供。
  • blog-src 博客源码存放的地方，也就是hexo相关的模板。
• 拥有与github关联的travis帐号。

单例模式

核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

常见的应用场景

• windows的Task Manager (任务管理器)就是很典型的单例模式
• windows的回收站也是典型的单例应用，在整个系统运行过程中，回收站一直维持着仅有的一个实例
• 项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件数据的时候都new一个对象去读取
• 网站计数器，一般也是采用单例模式实现，否则难以同步
• 应用程序的日志应用，一般采用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内存不好追加。
• 数据库连接池的设计一般也是采用的单例模式，因为数据库连接也是一种数据库资源
• Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc文件，而不会再次执行模块代码

单例模式的优点

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

单例模式可以再系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

常见的五种单例模式实现方式

• 主要：
  • 饿汉模式——单例对象立即加载(线程安全、调用效率高，但是不能延时加载)
  • 懒汉模式(线程安全，调用效率不高，但是可以延时加载)
• 其他：
  • 双重检测锁式(Java不建议使用)
  • 静态内部类式(线程安全，调用率高，同时也可以延时加载)
  • 枚举单例(线程安全，调用效率高，不能延时加载)

如何选用

• 单例对象 占用 资源少，不要 延时加载：
  • 枚举式 好于 饿汉式
• 单例对象 占用 资源大，需要 延时加载：
  • 静态内部类式 好于 懒汉式

python中单例模式的实现方式

本来想整理一下，以上说的几种常见的单例实现模式在Python中的实现表现，但是感觉对Java和Python理解的深度不够，懵懵懂懂之间，不敢胡乱总结，只得贴一些python自己的实现方式，没法进行对比了。先继续学习，深入了解一些再回来整理。

使用模块

Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。 因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

1
2
3
4
5
6
7
8
9
10
11
12

# mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()


# test.py
from mysingleton import my_singleton

my_singleton.foo()

使用 __new__

使用 __new__ 来控制实例的创建过程，这里没有线程的问题，下面的例子就是演示多线程的时候，看看是不是出问题，结果没有。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  

class MyClass(Singleton):  
    def __init__(self):
        import time
        time.sleep(1)


import threading

def task():
    obj = MyClass()
    print(obj)

for i in range(10):
	t = threading.Thread(target=task)
	t.start()

使用装饰器

装饰器（decorator）可以动态地修改一个类或函数的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def singleton(cls, *args, **kw):
    instance = {}
    def get_singleton():
        if cls not in instance:
            instance[cls] = cls(*args, **kw)
        return instance[cls]
    return get_singleton


@singleton
class TT(object):
    def __init__(self):
        self.num = 0
    def add(self):
        self.num = 100


if __name__ == '__main__':
    a = TT()
    print(a.num)  # 0
    a.add()
    b = TT()
    print(b.num)  # 100

虽然进行了两次实例化，但仍为同一个实例

使用 元类(metaclass)

• 类由type创建，创建类时，type的__init__方法自动执行，类() 执行type的 __call__方法(类的__new__方法,类的__init__方法)
• 对象由类创建，创建对象时，类的__init__方法自动执行，对象()执行类的 call 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import threading

class SingletonType(type):
    _instance_lock = threading.Lock()
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            with SingletonType._instance_lock:
                if not hasattr(cls, "_instance"):
                    cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
        return cls._instance

class Foo(metaclass=SingletonType):
    def __init__(self,name):
        self.name = name


obj1 = Foo('name')
obj2 = Foo('name')
print(obj1,obj2)

首先解释一下什么叫 API ：

应用程序接口（英语：Application Programming Interface，简称：API ），又称为应用编程接口，就是软件系统不同组成部分衔接的约定。由于近年来软件的规模日益庞大，常常需要把复杂的系统划分成小的组成部分，编程接口的设计十分重要。程序设计的实践中，编程接口的设计首先要使软件系统的职责得到合理划分。良好的接口设计可以降低系统各部分的相互依赖，提高组成单元的内聚性，降低组成单元间的耦合程度，从而提高系统的维护性和扩展性。(来自维基百科)

API 在多端中使用的更节省资源。网络应用程序，分为前端和后端两个部分。当前的发展趋势，就是前端设备层出不穷（手机、平板、桌面电脑、其他专用设备……）。因此，必须有一种统一的机制，方便不同的前端设备与后端进行通信。这导致API构架的流行。

关于RESTful的相关知识，参考设计一套良好 REST API

首先保证mongodb正确安装，并启动服务这篇文章讲解了windows下进行mongodb的安装和运行，启动mongo的命令行，打开一个命令行窗口，执行如下命令即可

mongo

转到用到的数据库

先用 mongo 命令行连接到一个 MongoDB 实例，转到 test 数据库。

use test

本文参考最新的 pymongo 官方文档进行整理，至文档更新时，PyMongo的版本号为3.6.1

先决条件

开始之前，请确保你的pymongo被正确安装，在 Python shell 中，应该运行以下代码而不会引发异常：

import pymongo

另外一个条件就是确保MongoDB实例正在默认主机和端口上运行(如果你的操作系统是windows，可以参考这篇文章进行mongodb的安装和运行)

2018年，新的开始，所以我用Python3.x啦，除了原有项目的维护外，全面升级到python3，人生苦短，就用python

7月3日

记住一句话：

当我们叠加装饰器的时候，最上层的装饰器会首先运行，接着调用下一行的下一个函数：要么是视图函数，要么就是装饰器。

6月26日

值得参考的python点击这里

字符串格式化：% 和.format

.format 在很多方便看起来更便利，对于 % 最烦人的是它无法同时传递一个变量和元祖，例如以下：

1

"hi there %s" % name 

但是，如果name恰好是(1, 2, 3）,它会抛出一个TypeError异常.为了保证它总是正确的,你必须这样做:

1

"hi there %s" % (name,)   # 提供一个单元素的数组而不是一个参数

但是有点丑..format就没有这些问题.你给的第二个问题也是这样,.format好看多了.

字典推导式

1

d = {key: value for (key, value) in iterable}