Month: 5月 2018

使用 supervisord 部署服务

Posted on 2018年5月24日2020年7月30日 by 逸飞

在某一刻你会意识到你需要写一个长期运行的服务。如果有错误发生，这些脚本不应该停止运行，而且当系统重启的时候应该自动把这些脚本拉起来。为了实现这一点，我们需要一些东西来监控脚本。这些工具在脚本挂掉的时候重启他们，并且在系统启动的时候拉起他们。

脚本

这样的工具应该是怎样的呢？我们安装的大多数东西都带了某种进程监控的机制。比如说 Upstart 和 Systemd。这些工具被许多系统用来监控重要的进程。当我们安装 php5-fpm，Apache 和 nginx 的时候，他们通常已经和系统集成好了，以便于他们不会默默挂掉。

然而，我们有时候需要一些简单点儿的解决方案。比如说我经常写一些 nodejs 的脚本来监控 github 上的某个动态并作相应的动作。node 可以处理 http 请求并且同时处理他们，也就是很适合作为一个一次性运行的服务。这些小的脚本可能不值得使用 Upstart 或者 Systemd 这种重量级的东西。

下面是我们的例子，把它放在 /srv/http.js 中

var http = require("http");

function serve(ip, port) {
    http.createServer(function (req, res) {
        res.writeHead(200, {"Content-Type": "text/plain"});
        res.write("\nSome Secrets:");
        res.write("\n"+process.env.SECRET_PASSPHRASE);
        res.write("\n"+process.env.SECRET_TWO);
        res.end("\nThere"s no place like "+ip+":"+port+"\n");
    }).listen(port, ip);
    console.log("Server running at http://"+ip+":"+port+"/");
}

// Create a server listening on all networks
serve("0.0.0.0", 9000);

这个服务仅仅是接受一个 http 请求并打印一条消息。在现实中并没有什么卵用，但是用来演示很好。我们只是需要一个服务来运行和监控。

注意到这个服务打印两个变量 “SECRETPASSPHRASE” 和 “SECRETTWO”。我们将会演示如何把这个传递个被监控的进程。

Supervisord

Supervisord 是一个使用很广也很简单的进程监控工具。

安装

supervisor 支持 python 3，也建议用这个版本。

brew install supervisor

在 linux 上可以通过 apt-get 来安装 supervisor，同样的命令。Centos 的命令请自己查询。

% sudo apt-get install supervisor
% sudo systemctl status supervisor
● supervisor.service - Supervisor process control system for UNIX
   Loaded: loaded (/lib/systemd/system/supervisor.service; enabled; vendor preset: enabled)
   Active: active (running) since Mon 2019-12-09 18:05:36 CST; 1min 15s ago
     Docs: http://supervisord.org
 Main Pwp_id: 1356 (supervisord)
    Tasks: 1 (limit: 4915)
   CGroup: /system.slice/supervisor.service
           └─1356 /usr/bin/python /usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

用系统的包管理器安装的好处是默认会设置 supervisord 的 systemd unit 文件，也就是已经开机启动了。

要想安装最新版本的 supervisor，可以使用 pip。但是需要自己设计开机启动

pip install supervisor

配置

下面我们来配置一个 supervisor 服务。

打开 /etc/supervisor/supervisord.conf，我们可以看到最后一行：

[include]
files = /etc/supervisor/conf.d/*.conf

所以我们只需要把我们的配置文件放在 /etc/supervisor/conf.d 文件夹下就好了。

[program:nodehook]
command=/usr/bin/node /srv/http.js
directory=/srv
autostart=true
autorestart=true
startretries=3
stderr_logfile=/var/log/webhook/nodehook.err.log
stdout_logfile=/var/log/webhook/nodehook.out.log
user=www-data
environment=SECRET_PASSPHRASE="this is secret",SECRET_TWO="another secret"

每个选项如下：

[program:xxx] 定义运行的服务的名字。
command 启动被监控的服务的命令，如果你需要传递命令行参数的话，也放在这里
directory 设定进程的运行目录
autostart 是否需要在 supervisord 启动的时候自动拉起
autorestart 是否在程序挂掉的时候自动重新拉起
startretries 如果启动失败，重试多少次
stderr_logfile 标准错误输出写入到哪个文件
stdout_logfile 标准输出写入到哪个文件
user 运行进程的用户
environment 传递给进程的环境变量

需要注意的是，supervisor 不会自动创建日志文件夹，所以需要我们首先创建好。

sudo mkdir /var/log/webhook

supervisor 配置文件的搜索路径包括：

/usr/local/etc/supervisord.conf
/usr/local/supervisord.conf
supervisord.conf  # 当前目录
etc/supervisord.conf
/etc/supervisord.conf
/etc/supervisor/supervisord.conf

控制进程

可以使用 supervisorctl 来控制对应的服务了。不过需要首先启动 supervisord 的 daemon 才行。

supervisorctl reread
supervisorctl update

这样就可以启动刚刚定义的服务。supervisorctl 的其他功能可以查看帮助

Web 界面

supervisor 自带了一个 web 界面。这样我们就可以通过浏览器来管理进程了。

在 /etc/supervisord.conf 中添加：

[inet_http_server]
port = 9001
username = user # Basic auth username
password = pass # Basic auth password

If we access our server in a web browser at port 9001, we’ll see the web interface:

注意

千万不要在 Docker 内部使用 supervisord 来启动多个进程，你这是在玩儿火！Docker 本身就是一个进程管理器，他的设计理念也是进程挂了就重启，如果你加了 supervisord 的话，很可能进程挂了，但是 supervisord 还活着，这样在 docker 看来整个服务就是健康的，殊不知 supervisord 可能在循环重启服务。总之，禁止套娃！

参考

https://serversforhackers.com/c/monitoring-processes-with-supervisord

mysql 基础知识 (7) – JSON 字段

Posted on 2018年5月20日2020年9月4日 by 逸飞

在前公司的时候，大家习惯在每个表加一个 extra 字段来表示一些额外的字段，然后在 ORM 中使用的时候再解析出来，方便了扩展字段，但是缺点也很明显，extra 字段只能读取而无法进行查询。MySQL 5.7 终于支持了 json 字段，相当于加入了一些 NoSQL 的特性，这样就可以很方便得查询了。

json 字段的使用

建表：

CREATE TABLE &#x60;book&#x60; (
  &#x60;id&#x60; mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
  &#x60;title&#x60; varchar(200) NOT NULL,
  &#x60;tags&#x60; json DEFAULT NULL,
  PRIMARY KEY (&#x60;id&#x60;)
) ENGINE=InnoDB;

直接使用 json 类型就可以了。注意 json 字段不可以作为主键，不可以作为外键，不过既然是 json 字段了，谁会这么做呢。

插入：

INSERT INTO &#x60;book&#x60; (&#x60;title&#x60;, &#x60;tags&#x60;)
VALUES (
  "ECMAScript 2015: A SitePoint Anthology",
  "["JavaScript", "ES2015", "JSON"]"
);

使用一个 json 字符串作为值插入即可。或者你也可以使用 json 相关的函数来表示 json。

json 相关函数

json path

-- returns "SitePoint":
SELECT JSON_EXTRACT(
  "{"id": 1, "website": "SitePoint"}",
  "$.website"
);

json path 的语法，用 $ 开头，然后跟着下面的选择器：

. 点后面跟着跟着一个字典里的名字，比如 $.website
[N] 表示数组里的第 N 个元素
.[*] 表示选择字典里的所有元素
[*] 表示选择数组里的所有元素
prefix**suffix 表示以 prefix 开头，suffix 结尾的所有路径

举个栗子

{
  "a": 1,
  "b": 2,
  "c": [3, 4],
  "d": {
    "e": 5,
    "f": 6
  }
}
the following paths:

$.a returns 1
$.c returns [3, 4]
$.c[1] returns 4
$.d.e returns 5
$**.e returns [5]

构造、修改 json 的函数

函数都比较简单，看注释就明白了。

-- returns [1, 2, "abc"]:
SELECT JSON_ARRAY(1, 2, "abc");

-- returns {"a": 1, "b": 2}:
SELECT JSON_OBJECT("a", 1, "b", 2);

-- returns ["a", 1, {"key": "value"}]:
SELECT JSON_MERGE("["a", 1]", "{"key": "value"}");

-- returns ARRAY:
SELECT JSON_TYPE("[1, 2, "abc"]");

-- returns OBJECT:
SELECT JSON_TYPE("{"a": 1, "b": 2}");

-- returns an error:
SELECT JSON_TYPE("{"a": 1, "b": 2");

-- returns 1:
SELECT JSON_VALID("[1, 2, "abc"]");

还有其他一些函数，可以查看文档：

JSON_SET(doc, path, val[, path, val]…) —
inserts or updates data in the document
JSON_INSERT(doc, path, val[, path, val]…) —
inserts data into the document
JSON_REPLACE(doc, path, val[, path, val]…) —
replaces data in the document
JSON_MERGE(doc, doc[, doc]…) —
merges two or more documents
JSONARRAYAPPEND(doc, path, val[, path, val]…) —
appends values to the end of an array
JSONARRAYINSERT(doc, path, val[, path, val]…) —
inserts an array within the document
JSON_REMOVE(doc, path[, path]…) —
removes data from the document.

查询 json 函数

用于 where 子句中的函数

json_contains 用于选取数组中包含某个元素的行

-- all books with the "JavaScript" tag:
SELECT * FROM &#x60;book&#x60;
WHERE JSON_CONTAINS(tags, "["JavaScript"]");

json_search 用于选取字典中包含某个值的行

-- all books with tags starting "Java":
SELECT * FROM &#x60;book&#x60;
WHERE JSON_SEARCH(tags, "one", "Java%") IS NOT NULL;

用于 select 子句中的 json 函数

可以使用 json path 语法从得到的 json 文档中抽取出某个值。

select 语句

要想在 select 语句中使用 json path 抽取元素可以使用下面的语法，也就是 column->path

SELECT
  name,
  tags->"$[0]" AS &#x60;tag1&#x60;
FROM &#x60;book&#x60;;

一个更复杂一点的例子：

id|name|profile
–|—-|——-
1|Craig|{“twitter”: “@craigbuckler”,“facebook”: “craigbuckler”,“googleplus”: “craigbuckler”}
2|SitePoint|{“twitter”: “@sitepointdotcom”}

SELECT
  name, profile->"$.twitter" AS &#x60;twitter&#x60;
FROM &#x60;user&#x60;;

SELECT
  name, profile->"$.twitter" AS &#x60;twitter&#x60;
FROM &#x60;user&#x60;
WHERE
  profile->"$.twitter" IS NOT NULL;

REF:

https://www.sitepoint.com/use-json-data-fields-mysql-databases/

如何发布 Python 代码到 PyPI 上（2018）

Posted on 2018年5月19日2020年7月30日 by 逸飞

PyPI 是 Python 的集中仓库。通过把代码上传到 PyPI，其他人就可以使用使用 pip install xxx 安装代码了。

Python 的安装工具一直在不断演变，PyPI 的地址也从 pypi.python.org 变到了 pypi.org，因此网上的教程大多数都过时了，官方文档更新比较及时，但是也略过繁琐，这里写一篇简要的教程以飨读者。

本文以作者的库 aioify 为例

文件结构

.
├── LICENSE.txt
├── MANIFEST.in
├── README.md
├── aioify
│   └── __init__.py
├── setup.cfg
└── setup.py

LICENSE.txt

库的开源协议，建议使用 Apache、MIT 等

MANIFEST.in

打包要包含的文件，Python 文件会自动包括在内，但是 README.md 不包含在内，所以需要特别注明：

include *.md
include LICENSE.txt

具体语法参见

README.md

说明文件，不多数了

aioify

这个是具体的代码的仓库

setup.cfg

用于指定 setup.py 的默认参数

[metadata]
description-file = README.md

setup.py

这个文件是整个打包过程的关键所在了。请参考下面的注释

import os
from distutils.core import setup

# 可选，读取 README 作为下面的 long_description
here = os.path.abspath(os.path.dirname(__file__))

with open(os.path.join(here, "README.md")) as f:
    long_description = f.read()


setup(
    name = "aioify",   # 包的名字
    packages = ["aioify"],   # 同上
    version = "0.1.3",    # 当前版本
    description = "Make every python function async/await",  # 描述
    long_description = long_description,  # 长描述，会显示在 PyPI 主页上
    long_description_content_type = "text/markdown",  # 长描述的格式，不过好像markdown支持还不是很好
    author = "Yifei Kong",  # 作者
    author_email = "kongyifei@gmail.com",  # 作者邮件
    url = "https://github.com/yifeikong/aioify",  # 项目地址
    download_url = "https://github.com/yifeikong/aioify/archive/0.1.3.tar.gz",  # 下载链接，可选
    keywords = ["async", "await", "wrap"],  # 关键词
    # 分类器，可以认为是 PyPI 的一些栏目，建议参考文档填写，可选
    classifiers = [
    "Development Status :: 3 - Alpha",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.5",
    "Programming Language :: Python :: 3.6",
    "Programming Language :: Python :: 3.7",
    ],
    python_requires=">=3.5"  # 最低 Python 版本
)

上传

本地测试

在项目的根目录，可以使用 pip 安装测试一下，看 setup.py 等文件是否有问题

pip install -e .

注册账户

在 pypi.org 注册一个账户。另外，在 test.pypi.org 再注册一个测试账户，因为两个站之间是独立的，所以得注册两次。

配置 .pypirc 文件

打开 ~/.pypirc 输入一下内容：

[distutils]
index-servers =
  pypi
  testpypi

[pypi]
username: 你的用户名
password: 密码

[testpypi]
repository:https://test.pypi.org/legacy/
username: 同上
password: 同上

上传到 test.pypi.org

test.pypi.org 是专门用来在正式上传前测试的服务器，以免操作失误。

打包

python setup.py sdist

然后可以看到多出了 dist/ 目录

上传

pip install twine  # 现在官方推荐使用twine工具
twine upload dist/* --repository testpypi

然后到 test.pypi.org/projects/xxx 就可以看到你的代码了~

上传到 pypi

一切验证无误之后，就可以上传到 PyPI 了：

twine upload dist/*

更多细节介绍请参见官方文档：

https://packaging.python.org/tutorials/distributing-packages/
https://packaging.python.org/guides/using-testpypi/

安装与配置

Posted on 2018年5月2日2020年7月30日 by 逸飞

安装 go 很简单，在 mac 上直接使用 brew install go 就可以了。注意的是需要设定GOPATH这个环境变量，如果不设定。默认就到了 ~/go 这个目录。GOPATH 中也可以设置多个目录，默认安装包会安装到第一个路径。不过现在

export GOPATH=$HOME/lib:$HOME/go

语法和风格

Golang 的整个语法还是极其简单的，基本是 C 和 Python 的混合体。Go 语言详尽地规定了代码的风格，所以就不用为了大括号究竟是放在哪儿而开始圣战了。Go 语言对程序员的约束很强，不容易犯错。

Go 语言官方提供了一个工具 goimports 用来管理 import 语句，还不错。

import进来的包必须使用，声明的变量也必须使用。import 语句必须在 package 语句后面。虽然有大括号，但是大括号的位置也是指定的。

类型

Go 语言有四种类型：基础类型、聚合类型、引用类型和接口类型。

var i int  // 声明一个变量
i = 42  // 赋值

或者直接使用简写：

i := 42  // 声明并赋值

几乎所有的值提供了默认都会初始化到对应的零值，即使没有初始化，不少函数处理 nil 的时候也是按照零值处理，这样避免了好多无谓的异常抛出。在go中也不会遇到len(None)这种问题，即使len(nil)也会返回0。

基础类型

整型包括了: int, int8/16/32/64, uint, uint8/16/32/64 几种类型。另外 byte 是 uint8 的别名，rune 是 int32 的别名。

比如定义了 size 函数，虽然返回的合法值都是 uint范围内的，但是可能使用 -1 等表示非法值。所以除非要使用比特位操作，尽量使用 int，而不是 uint。

浮点型也包括了：float32 和 float64 两种类型，注意没有单独的 float/double 类型。其中 math.MaxFloat32 和 math.MaxFloat64 表示最大值。默认的浮点数是 float64。

Go 中还包含了复数类型：complex64 和 complex128，不过就像 Python 中的复数类型一样，从来没用过。

字符串

值得一提的是 Go 中的字符串，实际上是一个 byte 的只读数组，如果使用索引访问的话，是按照 byte 为单位来访问的。但是在打印和 range 的时候会直接按照 utf-8 解码输出。如果需要按照 rune（Go 语言对 unicode code point 的称呼）来遍历，需要使用 unicode/utf8 这个包中的函数。

即使字符串不是 utf-8的，或者不管怎样用错了编码，至少不会panic，而python中时不时就会抛出UnicodeDecodeError 。

不用思考蛋疼的 Unicode 问题，不过虽然 Go 的 string 是 utf-8 的，但是使用下标访问的是字节，而使用 for range 访问的又是 rune。

Go 中的字符串，实际上是一个 byte 的只读数组，如果使用索引访问的话，是按照 byte 为单位来访问的。但是在打印和 range 的时候会直接按照 utf-8 解码输出。如果需要按照 rune（Go 语言对 unicode code point 的称呼）来访问，需要使用 unicode/utf8 这个包中的函数。

复合类型

Go 中内置的复合类型主要有三种：Array, Slice 和 Map。分别对应了其他语言中的定长数组、边长数组（切片）和字典。

像是 C 语言一样，Go 中也有定长数组，var a [3]int。

在 Go 中经常作为变长数组使用的是 Slice。Slice 指的是一个数组的一个切片。在 Go 语言中，默认的函数调用都是值传递的，但是 Slice 做参数的时候传递的是一个 Slice Header，也就相当于按照引用传递。

Map 类型是引用类型，也就是函数调用的时候是按照引用传递的。nil map 可以像空map一样使用，但是插入的时候会 panic，因为没有给他分配内存，所以 map 类型一般使用 make 初始化。

m := make(map[string]int)

数组

数组的类型是 [x]type，比如 [1]int 和 [2]int 是不同的类型

var a [3]int = [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
c := [...]int{1,2,3}
d := [...]{99: -1}

如果数组的元素是可以比较的(comparable)，那么数组也是也以比较的，也就是可以用来做 map 的 key。

默认情况下，数组是按照值传递的，这一点和 C 语言默认传递指针不一样。

向 nil 的 slice 中直接存入元素是不合法的，向 nil 的 map 中直接存入元素也是不合法的。所以最好使用 make 来声明map。

切片——变长数组

像是好多动态语言一样，Go 也支持切片操作：a[i:j]。不过和其他语言不一样的是，Go 的切片操作符产生了新的类型：切片，而不是数组。切片是对源数组的部分元素的一个引用。他们指向的是同一个内存单元。

切片可以当做一个变长数组使用，实际上我们不会每次都构造一个数组，然后获取切片，而是直接使用切片字面量。

a = []int{1, 2, 3}

和数组字面量很像，区别是没有指定长度。

和数组不同的一点是，切片是不能比较的，不管他内部的元素是什么。

Slice 底层引用了数组，但是并不会自动扩容，因此想往其中添加元素需要注意不能越界，提前扩充容量。可以使用 make 函数提前指定大小，或者使用 append 函数动态扩展切片大小。

make([]T, len)
make([]T, len, cap)


var x []int
x = append(x, 1)

Map

Go 语言也原生支持字典。

a := make(map[string]int)
a := map[string]int {
    "alice": 12,
    "bob": 12,
}

Go 语言和其他语言不同的是，尝试访问不存在的键也不会报错，而是会返回对应类型的零值，不过可以采用两个参数来验证是否存在这个键

v := a["foo"]
v, ok := a["foo"]

if v, ok : a["foo"]; ok {
    fmt.Print(v)
}

控制语句

go 还从 C 中继承了 if (p = fopen("xxx", "w")) != NULL 这种在把赋值语句写在if中的写法，不过好在 Go 语言中可以写做两句。

if err := r.ParseForm(); err != nil {
      //...
}

另外 switch 语句默认就会 break 了，而不是 fall through 了。

循环语句很有意思，Go 语言直接把 while 关键字扔掉了，只用 for 本身就够了

for {
// ...
}

就相当于其他语言中的 while(true) 了。

不管是 Python 中的 for…in… 还是 JavaScript 中的 for…of… 语句，迭代数组和字典的时候多少感到一些不一致。在 Go 语言中，还是比较统一的，每次迭代都会返回两个值：key， value。

迭代 slice

words := []string{"a", "b"}
for i, word := range words {
    fmt.Printf("%d -> %s", i, word)
}

迭代 map

words := make(map[string]string)
words["a"] = "a"
words["b"] = "b"
for k, v := range words {
    fmt.Printf("%s -> %s", k, v)
}

goroutine

goroutine 相对于 Python 的 coroutine 的好处就在于它是抢占的，不用主动交出。

Python 的 coroutine 需要特别小心不要调用阻塞性的函数，比如 time.sleep，而要使用asyncio.sleep，所以写起来不是非常得方便。Python必须使用 await 来显式交出控制，而 Go 中则没有这种限制。

Timers and tickers

Timers 定义在你在未来的某个时间想要去做一次某件事。而 Tickers 则是定期执行某一个动作。这两个有点像是 js 里面的 setTimeout 和 setInterval 两个函数。

defer 实际上就相当于 C++ 中的RAII，和Python中的 with 语句

Go 的类型总体来说，和 Python 的 duck type 有点像，而和 Java 严格的继承则是完全背道而驰的。

发生赋值时候会不会检查类型呢？

interface{}

io

一般读取统一从 io.Reader 类型中读取

记得一定要使用append函数，而不要直接在slice的结尾通过下标添加字符，这样可能会panic

函数应该接受 interface 作为参数，并使用 struct 作为返回值。

目前为止有几个不爽的地方

nil 字典不能直接赋值，但是 nil slice 可以 append
interface 的 nil 始终没有搞明白。empty slice(a[0:0]) 和 nil 也不一样
没有一个统一的包管理工具，刚刚花一下午时间学习了 dep，号称是官方的试验，结果又看到一篇文章说 vgo 要取代 dep，WTF
defer 执行的地方是函数的结尾，而不是块的结尾

数据类型

s := "世界"

len(s)  // -> 6，utf-8 编码的中文一般是3个字节。
utf8.RuneCountInString(s)  // -> 2

// 使用 range 遍历
for r := range s {
    fmt.Printf("%s", r)
}

// 使用 DecodeRuneInString
for i := 0; i < len(s) {
    r, size := utf8.DecodeRuneInString(s[i:])
    fmt.Printf("%d\t%c\n", i, r)
}

// 全部转换成 rune
r := []rune(s)
fmt.Printf("%x\n", r)

即使字符串不是 utf-8的，或者不管怎样用错了编码，至少不会 panic，而是把不能解析的字符替换成 \uFFFD。而python中时不时就会抛出UnicodeDecodeError，非常蛋疼。

Go 语言中的字符串函数并没有作为 string 类型的方法，而是单独放在了 strings 包中，比如 strings.Split，strings.Join 函数。因为 []byte 类型和 string 类型也比较类似，因此 strings 包中提供的方法，在 bytes 包中也可以找到类似的。

复合类型

Struct

定义一个 struct 如下：

type A struct {
    foo int
    bar int
}

Go 中也有指针的概念，不过没有 -> 这个关键字，统一使用 . 操作。如果一个 struct 中的所有字段都是可以比较的，整个 struct 就也是可以比较的。

Struct 嵌入

Go 语言支持一种特殊的骚操作，叫做 struct 嵌入。这样一个 struct 就可以直接调用被嵌入的 struct 的属性和方法，听起来有点像继承，而且的确实现了继承的功能，但的确不是继承，而是复合。

Go 语言是一门有 gc 的语言，所以所有变量的生命周期并不是严格限定于作用域的，由编译器来决定使用栈上还是堆上的空间。

在 Go 语言中没有 private 和 public 这些关键字。如果变量名字是大写字母开头的，那么就是导出的，如果是小写字母开头的，那么就是包内私有的变量。

参考：

https://stackoverflow.com/questions/18058164/is-a-go-goroutine-a-coroutine

Python urllib 模块

Posted on 2018年5月1日2020年9月4日 by 逸飞

YN：网络访问的时候一定要记得设置一个合理的超时

在 Python2 中，有两个 urllib：urllib 和 urllib2，urllib 基本只使用 urllib.urlencode(), urllib.quote 函数，其他功能都被对应的 urllib2 中的函数替代了。

Python3 把这两个模块进行了合并并拆分成了子模块，只使用 urllib 就好了。

发送 http 请求

直接使用 urlopen

urllib.request.urlopen(url, data=None, [timeout, ] *, context) -> http.client.HTTPResponse

用于发送 GET 或者 POST 请求，如果有 data，则发送的是 POST 请求. 返回一个 file-like 的 http.client.HTTPResponse 对象，这个对象也可以作为一个 context manager。

info() | 返回 headers
gerurl() | 返回 url，常用于判定是否被重定向
getcode() |
read()/readlines() | 返回文件内容

>>> import urllib.request
>>> with urllib.request.urlopen("http://www.python.org/") as f:
...     print(f.read(300))
...
b"<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n\n\n<html
xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">\n\n<head>\n
<meta http-equiv="content-type" content="text/html; charset=utf-8" />\n
<title>Python Programming "

使用 Request 对象

如果需要更改默认的 header 等数据或者使用 PUT、DELETE 等方法，urlopen 还可以接受一个 Request 对象，可以在 Request 对象中更改。

Request 对象的定义：

class urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)

一个 request 可以指定 method， url，可以使用 req.add_header 添加 header。

可以使用 addheader 方法再添加额外的 header，但是实际上是 setheader，并不能添加重复的，不要被名字迷惑了。

使用 Opener

urilib2.build_opener 返回一个打开器 (OpenerDirector)，用于设定发出请求要经过的一些处理，可以设定代理，处理 cookie 等。OpenerDirector 有一个属性 addheaders，把他设定为一个包含键值 tuple 的 list，这样使用 opener 发送的每一个请求都会添加上这个 header。

Then you could use opener.open instead of urllib2.urlopen

Typical usage:

import urllib2
import urllib
from cookielib import CookieJar
cj = CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
# input-type values from the html form
formdata = { "username" : username, "password": password, "form-id" : "1234" }
data_encoded = urllib.urlencode(formdata)
response = opener.open("https://page.com/login.php", data_encoded)

import urllib.request
opener = urllib.request.build_opener()
opener.addheaders = [("User-agent", "Mozilla/5.0")]
opener.open("http://www.example.com/")

From http://stackoverflow.com/questions/3334809/python-urllib2-how-to-send-cookie-with-urlopen-request

异常：URLError HTTPError

URLError 是 IOError 的子类，HTTPError.code is the http code

urllib.parse

urlparse and urlunparse is not as good as urlsplit

urlsplit

return a five element tuple by scheme://netloc/path?query#fragment

Attribute Index Value Value if not present
scheme 0 URL scheme specifier scheme parameter
netloc 1 Network location part empty string
path 2 Hierarchical path empty string
query 3 Query component empty string
fragment 4 Fragment identifier empty string
username User name None
password Password None
hostname Host name (lower case) None
port Port number as integer, if present None

note，the netloc contains domain and port

>>> urlsplit("www.cwi.nl/%7Eguido/Python.html")
SplitResult(scheme="", netloc="", path="www.cwi.nl/%7Eguido/Python.html", query="", fragment="")
# notice the netloc will be wrong if "//" is missing
>>> urlsplit("//www.cwi.nl/%7Eguido/Python.html")
SplitResult(scheme="", netloc="www.cwi.nl", path="/%7Eguido/Python.html", query="", fragment="")

urlunsplit join the parse result。

parse_qs(qs, keep_blank_values=False, encoding="utf-8")

parse a query string to { key: [values] } pair, note without ‘?’

parse_qsl

return a list of k,v tuple

quote/quote_plus

unquote

urlencode

Python 中的 iterator 和 generator

Posted on 2018年5月1日2020年7月30日 by 逸飞

这篇文章里面有不少概念都是错的，需要改进

迭代器

In Python, iterable and iterator have specific meanings.

An iterable is an object that has an iter method which returns an iterator, or which defines a getitem method that can take sequential indexes starting from 0 (and raises an IndexError when the indexes are no longer valid). So an iterable is an object that you can get an iterator from.

calling iter(iterable) will return a iterator

An iterator is an object with a next (Python 2) or next (Python 3) method.
Whenever you use a for loop, or map, or a list comprehension, etc. in Python, the next method is called automatically to get each item from the iterator, thus going through the process of iteration.

Generators

Generators are iterators, but you can only iterate over them once. It’s because they do not store all the values in memory, they generate the values on the fly.

def generator_function():
    for i in [0, 1, 2]:
        yield i * 2
for item in generator_function():
    print(item)
# Output: 0
# 2
# 4

as you can see, generators are typically a filter or mapper between sequences

def fib(n):
    a = b = 1
    for i in range(n):
        yield a
        a, b = b, a + b

From http://book.pythontips.com/en/latest/generators.html

迭代器协议

with open('file') as f:
    try:
        while True:
            value = next(f)
            print value
    except StopIteration:        pass

The word “generator” is confusingly used to mean both the function that generates and what it generates. In this chapter, I’ll use the word “generator” to mean the genearted object and “generator function” to mean the function that generates it.

Can you think about how it is working internally?

When a generator function is called, it returns a generator object without even beginning execution of the function. When next method is called for the first time, the function starts executing until it reaches yield statement. The yielded value is returned by the next call.
The following example demonstrates the interplay between yield and call to next method on generator object.

django forms

Posted on 2018年5月1日2020年7月30日 by 逸飞

django 中的 form 和 model 的用法很像，都是定义一个类，然后指定一些字段就可以了

最简单的form

from django import forms

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    email = forms.EmailField(required=False)
    message = forms.CharField(widget=forms.Textarea)

    def clean_message(self):
        message = self.cleaned_data['message']
        num_words = len(message.split())
        if num_words < 4:
            raise forms.ValidationError("Not enough words!")
        return message

def contact(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            send_mail(
                cd['subject'],
                cd['message'],
                cd.get('email', 'noreply@example.com'),
                ['siteowner@example.com'],
            )
            return HttpResponseRedirect('/contact/thanks/')
    else:
        form = ContactForm()
        return render(request, 'contact_form.html', {'form': form})

<form action="" method="post">
    <table>
        {{ form.as_table }}
    </table>
    {% csrf_token %}
    <input type="submit" value="Submit">
</form>

Note not include table/ul/form tags, just the inside tags

ajax

ajax 中如何指定 crsf token

axios 中：

import axios from 'axios';
axios.defaults.xsrfHeaderName = "X-CSRFTOKEN";
axios.defaults.xsrfCookieName = "csrftoken";

settings.py 中

CSRF_COOKIE_NAME = "csrftoken"

参考

https://stackoverflow.com/questions/39254562/csrf-with-django-reactredux-using-axios