发表于 | 分类于 |

range是迭代器吗

一直以为range是迭代器，所以很自然地用next方法试图迭代它的时候，居然报了下面的错误：

1
2
3
4
5
6
7
8
#range不是迭代器的事实
x = range(3)
print(next(x))
-------------------
Traceback (most recent call last):
  File "pythonscripts/iterator_and_range.py", line 8, in <module>
    print(next(x))
TypeError: 'range' object is not an iterator

那么这就有意思了，既然range不是迭代器，那么它究竟是什么？

迭代器的特性

我们先来复习一下迭代器的定义,　迭代器是指实现了迭代协议的对象，迭代协议是指实现了iter方法并返回一个实现了next方法的迭代器对象，并通过StopIterator异常标识迭代完成。

使用iter函数可以从任何可迭代对象中获取一个迭代器

1
2
3
4
5
6
7
8
s = iter([1,2,3])
print(s)
print(next(s))
print(1 in s)
-----------------
<list_iterator object at 0x7f7694fc4a20>
1
False

迭代器有个特点，即每用完一个元素即消耗掉该元素，不会保留在迭代器中，也就是说，是一次性的。

迭代器上使用iter会得到相同的对象

1
2
3
4
5
6
7
8
s = iter([1,2,3])
print(iter(s) is s)
print(id(iter(s)))
print(id(s))
------------------
True
140143916509728
140143916509728

利用这个特性，我们可以实现一些特殊的操作：

1
2
3
4
s = iter([1,2,3,4])
list(zip(s,s))
------------------
[(1, 2), (3, 4)]

range有上述的特性吗

1
2
3
4
5
6
s = iter(range(5))
print(s)
print(next(s))
------------------
<range_iterator object at 0x7fef611b9a20>
0

从这里可以看出iter可以用在range上，并返回了一个迭代器。

1
2
3
4
5
6
7
8
x = range(5)
print(1 in x)
print(2 in x)
print(1 in x)
-------------
True
True
True

这里可以看出，range并不是一次性的，而是可以重复地使用，不符合迭代器一次性的特性

而且，迭代器（生成器）并不支持长度，而range支持len方法：

1
2
3
4
5
6
7
x = iter([1,2,3])
print(len(x))
-------------
Traceback (most recent call last):
  File "pythonscripts/iterator_and_range.py", line 11, in <module>
    print(len(x))
TypeError: object of type 'list_iterator' has no len()

也不可以被索引:

1
2
3
4
5
6
7
x = iter([1,2,3])
print(x[0])
------------
Traceback (most recent call last):
  File "pythonscripts/iterator_and_range.py", line 11, in <module>
    print(x[0])
TypeError: 'list_iterator' object is not subscriptable

综上，range并不是迭代器，而且跟迭代器有着明显的区别，只是range是一种可迭代的对象，表面上看起来像迭代器而已。

那么，range究竟是什么

range实现是c语言写的，源码可以在安装路径下找到，这里我们看一下help方法给我们的结果:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
Help on class range in module builtins:
class range(object)
 |  range(stop) -> range object
 |  range(start, stop[, step]) -> range object
 |  
 |  Return an object that produces a sequence of integers from start (inclusive)
 |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
 |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
 |  These are exactly the valid indices for a list of 4 elements.
 |  When step is given, it specifies the increment (or decrement).
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      Return a reverse iterator.
 |  
 |  count(...)
 |      rangeobject.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      rangeobject.index(value, [start, [stop]]) ->  integer -- return index of value.
 |      Raise ValueError if the value is not present.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  start
 |  
 |  step
 |  stop

　可以看出range的迭代是通过iter协议实现的，像len等对应的方法也是通过len等方式实现的，也就是说range其实是一种类似迭代器的鸭子类型，而并非真正的迭代器！

发表于 | 分类于 |

协议和接口

python中的协议和接口的概念不一样，接口是类似其他编程语言中一样比较严格的定义方式，而协议的概念有种约定俗成的味道。python中的有种鸭子类型的称呼，即说的就是通过协议的方式实现的行为。例如，python中的序列，如果通过抽象类的继承的方式就需要实现Sequence类下的多个抽象方法，而鸭子类型就让我们只通过实现getitem方法就能让我们的类的部分表现像序列一样，可以通过下标进行取值。

协议是一种非正式的接口，因此不能像正式接口那样施加限制。一个类可以实现多个协议，从而令类的表现像从多个继承来的一样（事实上并没有）。

抽象类

python中也可以像其他语言一样定义抽象类，不过大多时候不需要这么做，常见的做法是继承已经存在的抽象基类。

下面说明如何继承一个已经存在的抽象类：

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
from collections import MutableSequence, namedtuple
Card = namedtuple("Card", ["rank", "suit"])
class FrenchDeck(MutableSequence):
    ranks = [str(n) for n in range(2, 11)] + list("JKQA")
    suits = 'spades diamonds clubs harts'.split()
    def __init__(self):
        self._cards = [Card(rank, suit)
                       for suit in self.suits for rank in self.ranks]
    def __getitem__(self, position):
        return self._cards[position]
    def __setitem__(self, position, value):
        self._cards[position] = value
    def __len__(self):
        return len(self._cards)
    def __delitem__(self,position):
        del self._cards[position]
    def insert(self,position,value):
        self._cards.insert(position,value)
f = FrenchDeck()

继承抽象基类的子类必须全部实现抽象基类中的抽象方法，像例子中的getitem,__setitem,\len,\delitem__,insert这些方法是必须实现的，否则在运行过程中python会告诉你没有实现某个方法而报警：

1
2
3
4
Traceback (most recent call last):
  File "pythonscripts/abc_frenchdeck.py", line 29, in <module>
    f = FrenchDeck()
TypeError: Can't instantiate abstract class FrenchDeck with abstract methods __delitem__, insert

collections.abc模块中的抽象基类

标准库中的抽象基类大多数在collections.abc模块中定义，部分在numbers和io中。

常见的抽象基类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Iterable
Container
Sized
Callable
Hashable
Iterator
Sequence
Mapping
Set
MappingView
MutableSequence
MutableMapping
MutableSet
ItemsView
KeysView
ValuesView

自定义抽象基类

尽管不推荐自定义抽象基类，但是在某些特殊的情况下还是有需要自己创建抽象基类的，创建抽象基类需要继承自abc.ABC 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import abc
class animal(abc.ABC):
    @abc.abstractmethod
    def run(self):
        ''''''
    @abc.abstractmethod
    def eat(self):
        ''''''
    @abc.abstractmethod
    def shit(self):
        ''''''

abc.ABC是从python3.4后新增的，对于之前的版本必须使用metaclass=关键字：

1
class animal(metaclass=abc.ABCMeta):

对于python2 则只能通过metaclass来实现了:

1
2
class animal(object):
    __metaclass__ = abc.ABCMeta

虚拟子类

除了继承，其实还在另外一种将类注册为抽象基类的子类的方法，通过register方法.

例如，我们实现一个dog类，但不继承：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@animal.register
class dog:
    
    def run(self):
        print('10km/s')
    def eat(self):
        print('eat meat')
    def shit(self):
        print('pull shit')
d = dog()
print(isinstance(d,animal))
print(issubclass(dog,animal))
---------------
True
True

register方法可以通过装饰器的方式放在子类上（对于3.3版本以前的python只能调用标准的句法），由上面的例子可以看出来，isinstance和issubclass都认可子类的这个事实。

但是在mro中，却没有列出animal，说明dog并不是从mro中继承而来的：

1
2
3
print(dog.__mro__)
-----------------
(<class '__main__.dog'>, <class 'object'>)

另外一个事实

某些情况下，即使不使用register方法，也能把一个类注册为抽象基类的子类。看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
from collections import abc
class demo:
    def __len__(self):
        return 3
print(isinstance(demo(),abc.Sized))
print(issubclass(demo,abc.Sized))
--------------
True
True

这里的子类只实现了一个len竟然也成了抽象基类Sized的子类，那么原理是什么呢？

这是因为Sized实现了一个特殊的方法subclasshook：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Sized(metaclass=ABCMeta):
    __slots__ = ()
    @abstractmethod
    def __len__(self):
        return 0
    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            if any("__len__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

由Sized源码我们可以看到了我们要的答案。

虽然这为我们实现提供了另外的一种思路，但是还是不推荐这么做，因为，Sized这里是个特例，len方法的目的十分明确，而在我们自己实现过程中，恐怕是很难有这么明确的行为目的的。

发表于 | 分类于 |

猴子补丁的定义

所谓猴子补丁，即不在源码中进行改动，而是在代码运行时改动的类或模块

示例

我们新建两个类，一个猴子类和一个猴群类：

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
class Monkey:
    '''
    猴子类
    '''
    def __init__(self,name):
        self.name = name
class Monkeys:
    '''
    猴群
    '''
    _monkeys = []
    def __init__(self,monkeys):
        self._monkeys = monkeys
    def __getitem__(self,position):
        return self._monkeys[position]
    def __len__(self):
        return len(self._monkeys)
    def __repr__(self):
        return "<monkeys {}>".format(','.join((m.name for m in self)))

由定义可以看出，猴群类实现了序列协议，支持下标取值和长度判断。
接下来创建5个猴子，并让他们按顺序排好队：

1
2
3
4
5
6
7
8
9
10
11
m1 = Monkey("猴1")
m2 = Monkey("猴2")
m3 = Monkey("猴3")
m4 = Monkey("猴4")
m5 = Monkey("猴5")
monkeys = Monkeys([m1,m2,m3,m4,m5])
print(monkeys)
--------------
<monkeys 猴1,猴2,猴3,猴4,猴5>

现在我们想要将其顺序打乱，shuffle一下看看:

1
2
3
4
5
6
7
8
9
10
from random import shuffle
shuffle(monkeys) #不支持打乱
---------------
Traceback (most recent call last):
  File "pythonscripts/mokey_patch.py", line 47, in <module>
    shuffle(monkeys) #不支持打乱
  File "/usr/lib/python3.5/random.py", line 272, in shuffle
    x[i], x[j] = x[j], x[i]
TypeError: 'Monkeys' object does not support item assignmen

猴群不支持打乱的原因是因为Monkeys类并没有实现setitem方法，接下来，我们利用猴子补丁，给猴群添加打乱的功能:

1
2
3
4
5
6
7
8
9
def set_monkey(monkeys,position,monkey):
    monkeys._monkeys[position]  = monkey
Monkeys.__setitem__ = set_monkey
shuffle(monkeys)
print(monkeys)
--------------
<monkeys 猴1,猴5,猴4,猴2,猴3>

这里猴群已经被打乱了，而且我们并没有改动源码，只是在代码运行中给Monkey类添加了setitem方法，这就是猴子补丁的作用。

发表于 | 分类于 |

爬虫写完了，那么如何将他部署到服务器上呢？因为我们使用的是scrapy框架，所以这里使用对应的scrapyd来部署

安装 scrapyd

在服务器端安装scrapyd：

1
pip install scrapyd

安装完成后，使用命令：

1
scrapyd

访问http://localhost:6800/ 可以看见一个控制台

客户端安装

客户端使用：

1
pip install scrapyd-client

安装完成后在工程目录下使用如下命令上传项目：

1
scrapy-deploy localhost -p douban

说明 这里的localhost 是你在爬虫目录下的scrapy.cfg文件中定义的服务器名称，-p 后跟爬虫名称

1
2
3
4
5
6
7
8
9
10
11
12
13
# Automatically created by: scrapy startproject
#
# For more information about the [deploy] section see:
# https://scrapyd.readthedocs.org/en/latest/deploy.html
[settings]
default = douban.settings
[deploy:localhost]
url = http://localhost:6800/
project = douban
username = scrapy
password = secret

执行命令的API

主要使用curl工具来对爬虫进行管控

启动

1
curl http://localhost:6800/shchedule.json -d project=douban -d spider=xxx

停止

1
curl http://localhost:6800/shchedule.json -d project=douban -d job=xxxxx

这里的jobid会在启动的时候返回，也可以通过web页面找到。

发表于 | 分类于 |

ubuntu上缺少onedrive和google云盘的客户端，虽然有各种命令行的方式，但是操作起来还是相对比较复杂，于是转向了dropbox。
dropbox有deb的安装包，但是拜天朝的局域网所赐，根本无法安装，进度条动都不动，索性的是，已经装好了ss-qt5,可以借此东风来进行安装。

安装dropbox

  1. 首先去官网下载deb包

  2. 安装proxychains：

    1
    sudo apt install proxychains

  3. 修改proxychains的配置

    1
    2
    3
    sudo vi /etc/proxychains.conf 
    // 将最后一行修改为 socks5 127.0.0.1 1080
    // 前提是本机安装了 SS-Qt5

  4. 启动dropbox安装

1
proxychains dropbox start -i

发表于 | 分类于 |

平行赋值

* 运算符在python3中被扩展到了平行赋值：

1
2
3
4
a,b, *c = range(5)
c
[2,3,4]

这在python2中是不被允许的

元组不再可以作为函数的参数

在python2中，可以把元素作为参数放到函数的声明中：

1
2
3
4
5
>>> def test(a,(b,c),d):
...     print b,c
... 
>>> test(1,(2,3),4)
2 3

但python3不再支持这种方式：

1
2
3
4
5
>>> def test(a,(b,c),d):
  File "<stdin>", line 1
    def test(a,(b,c),d):
               ^
SyntaxError: invalid syntax

一个诡异的+=谜题

1
2
3
4
5
6
7
8
>>> t = (1, 2, [20, 30])
>>> t[2] += [40,50]
请问结果会是怎样
a. t = (1, 2, [20,30,40,50])
b. 因为t是不可变量，程序报错
c. a和b都不对
d. a和b都正确

答案是d,程序会像预期的那样报错，但却完成了赋值的操作。

1
2
3
4
5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, [20,30,40,50])

原因在于t[2]是个变量的引用，+=操作会让list的操作正常的完成，但给元素赋值的操作会发生异常，这并不是一个原子操作，因而出现了这种结果。可以这么理解：

1
2
3
>>> b = [20,30]
>>> t = (1, 2, b)
>>> t[2] += [40,50]

对b的操作会反应到t当中，但是没有赋值操作。

发表于 | 分类于 |

在使用Dockerfile构建完镜像之后，run容器的时候有时候会报下面的错误：

1
standard_init_linux.go:190: exec user process caused "no such file or directory"

sh本身写的没有错误，经排查是编码格式的问题，使用编辑器把sh文件的换行由CRLF换成LF即可。

发表于 | 分类于 |

有时候启动了多个容器或是构建了多个镜像，会导致存在多个无用的容器和镜像，一个一个删除的话太费劲，想要实现批量删除，借助于grep和awk工具，我们可以轻松实现这个目的

例如：

1
2
3
4
5
6
7
8
9
10
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                        PORTS                              NAMES
13563a04bb6a        odoo:qunar          "/entrypoint.sh open…"   44 hours ago        Exited (255) 12 minutes ago   0.0.0.0:8069->8069/tcp, 8071/tcp   inspiring_jang
fa1ee76c7261        odoo:qunar          "/entrypoint.sh open…"   44 hours ago        Created                                                          optimistic_leavitt
aebb10ced752        be7df4762b94        "/entrypoint.sh open…"   44 hours ago        Exited (0) 44 hours ago                                          amazing_bhabha
a432735ce166        be7df4762b94        "/entrypoint.sh open…"   44 hours ago        Created                                                          sharp_pasteur
63bece7c8bc1        817de5cdbd08        "/entrypoint.sh open…"   44 hours ago        Exited (0) 44 hours ago                                          optimistic_stonebraker
737e3321ce5e        fd41c1224def        "/bin/sh -c 'apt-get…"   44 hours ago        Exited (1) 44 hours ago                                          wonderful_panini
4481a015c6eb        a9cbf361b39e        "/entrypoint.sh open…"   45 hours ago        Exited (0) 44 hours ago                                          laughing_euler
9a6f8823eeba        e83                 "/entrypoint.sh odoo"    3 days ago          Exited (137) 2 days ago                                          odoo10e
681c7db9d75e        23c                 "/entrypoint.sh odoo"    3 days ago          Exited (0) 3 days ago                                            odoo10

存在多个container，想要保留odoo相关的容器，而删除其他无用的容器，可使用下面的命令：

1
docker rm `docker ps -a | grep -v 'odoo' |awk '{print $1}'`

再例如：

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
root@venus:/home/kevin/codes# docker images
REPOSITORY                              TAG                 IMAGE ID            CREATED             SIZE
odoo                                    qunar               3a4a40aadd32        44 hours ago        813MB
kevinkong/odoo                          qunar               3a4a40aadd32        44 hours ago        813MB
kevinkong/odoo                          <none>              be7df4762b94        45 hours ago        813MB
<none>                                  <none>              817de5cdbd08        45 hours ago        1.03GB
<none>                                  <none>              a9cbf361b39e        45 hours ago        1.01GB
<none>                                  <none>              0b3555aabbf3        45 hours ago        742MB
<none>                                  <none>              eb03fdc57fd9        45 hours ago        114MB
odoo                                    v8                  0f7422de5013        46 hours ago        742MB
<none>                                  <none>              94f880258a54        46 hours ago        742MB
<none>                                  <none>              f7af934b7a01        47 hours ago        742MB
<none>                                  <none>              88e8eaf89647        47 hours ago        742MB
<none>                                  <none>              131e637d520a        47 hours ago        742MB
<none>                                  <none>              12ba63a4471f        47 hours ago        742MB
<none>                                  <none>              f52ae88b0c3c        2 days ago          742MB
flask_order                             test                f9229334fe7a        2 days ago          1.15GB
kevinkong/odoo                          v10e                e834d58329c2        3 days ago          1.11GB
odoo                                    v10e                e834d58329c2        3 days ago          1.11GB
kevinkong/odoo                          v10                 23c958989020        4 days ago          1.01GB
odoo                                    v10                 23c958989020        4 days ago          1.01GB
python                                  3.6                 d330010a503a        5 days ago          912MB
registry.docker-cn.com/library/python   3.6                 d330010a503a        5 days ago          912MB
kevinkong/odoo                          v8                  cc0330013b8b        5 days ago          742MB
ubuntu                                  16.04               5e8b97a2a082        4 weeks ago         114MB
registry.docker-cn.com/library/ubuntu   16.04               5e8b97a2a082        4 weeks ago         114MB
hello-world                             latest              e38bc07ac18e        2 months ago        1.85kB

想要删除所有包含none的镜像，可使用如下命令:

1
docker rmi `docker images | grep 'none' | awk '{print $3}'`

发表于 | 分类于 |

问题是这样的，在使用docker制作odoo 8 某个特定的版本的时候，突然冒出了这个提示：

1
UnicodeDecodeError: 'ascii' codec can't decode byte 0x?? in position 1: ordinal not in range(128)

因为odoo 8使用的还是python2.7的版本，这个问题基本是老生常谈的问题，心想这还不简单，一顿骚操作：

手写了一个sitecustomize.py，设置python的encoding为utf8，放到Dockerfile的文件夹下，Dockerfile里加一句COPY到python的路径中，搞定。

自信满满的重新构建了镜像，然后开启容器，打开浏览器准备访问，发现没反应。什么鬼，难道又挂了？
docker logs一看，果然，又挂了，可是为什么还是上面那个错？

问题的排查

不信这个邪了，首先怀疑的是sitecustomize.py文件没有起作用。exec进容器，然后打开一个python terminal,
sys.getdefaultencoding()看了一下：

1
2
3
import sys
sys.getdefaultencoding()
utf8

这就说明python的encoding设置正确了，*他大爷的，那问题会出现在哪呢？

我把自定义的addons删掉，重启，一切正常。

难道是python不能输出中文？
写个脚本，上传到容器中：

1
2
3
print u'中文'
中文

也正常运行了，那到底是为啥呢？

没办法，只好又看一了下错误日志，在报错的地方加了一句输出，重启。
在输出的日志中，看到了这么一行：

1
2
3
...
/home/.../行政区域.xlsx
...

原来是因为路径中存在中文导致的报错，可是python为啥读不了中文呢？
这时候我突然想起来，该镜像是从官方的ubuntu制作而来，既然是官方，自然默认的语言设置就是英文了。
马上看一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
locale
LANG=
LANGUAGE=
LC_CTYPE="POSIX"
LC_NUMERIC="POSIX"
LC_TIME="POSIX"
LC_COLLATE="POSIX"
LC_MONETARY="POSIX"
LC_MESSAGES="POSIX"
LC_PAPER="POSIX"
LC_NAME="POSIX"
LC_ADDRESS="POSIX"
LC_TELEPHONE="POSIX"
LC_MEASUREMENT="POSIX"
LC_IDENTIFICATION="POSIX"
LC_ALL=

果然不是utf-8！

问题终于找到了，解决方案也非常简单，在Dockerfile中加一句：

1
ENV LANG C.UTF-8

你看，本来一位非常简单的问题，却饶了这么一个大弯~~