谢乾坤 | Kingname

在看Kenneth Reitz大神的Records项目时，注意到在Readme中，读取数据有三种写法：

Values can be accessed many ways: row.user_email, row[‘user_email’], or row[3]

假设一个数据表如下所示：

那么，当你想读取user_email这一列的时候，除了可以使用row.user_email和row['user_email']以外，由于user_email在第3列（username是第0列），所以还可以使用row[3]来读取。

今天我们就来研究一下，他是如何实现这个功能的。

假设我们现在有一个类：

1
2
3
4
5
6
7

class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def walk(self):
        print('i am walk')

基于这个类初始化一个对象kingname:

1
2

kingname = People('kingname', 26)
print(kingname.age)

运行效果如下图所示：

可以看到，我们已经实现了类似于records项目中的row.user_email的写法。

但是当我们想像字典一样取读取的时候，就会报错，如下图所示。

此时，为了让一个对象可以像字典一样被读取，我们需要实现它的__getitem__方法：

1
2
3
4
5
6
7
8
9
10

class People:
    def __init__(self, name, age):
        self.info = {'name': name,
                     'age': age}
    
    def walk(self):
        print('i am walk')

    def __getitem__(self, key):
        return self.info.get(key, '不存在')

此时就可以像字典一样去读取了，运行效果如下图所示：

但新的问题又来了，不能直接读取使用kinganme.age读取数据了，这样写会导致报错，如下图所示：

为了解决这个问题，我们再来实现这个类的__getattr__方法：

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

class People:
    def __init__(self, name, age):
        self.info = {'name': name,
                     'age': age}
    
    def walk(self):
        print('i am walk')

    def __getitem__(self, key):
        return self.info.get(key, '不存在')
        
    def __getattr__(self, key):
        return self.info.get(key, '不存在')

运行效果如下图所示：

那么如何实现records里面的row[3]这种写法呢？这就需要先解释一下，records这个库是用来做什么的，以及它的数据是如何存放的。

K大写的records这个库，是用于来更加方便地读写SQL数据库，避免繁琐地写各种SQL语句。

这个库的源代码只有一个文件：源代码

我们今天要研究的这个写法，在Record这个类里面。这个类用来保存MySQL中的一行数据。Record这个类包含两个属性，分别为_keys和_values，其中_keys用于记录所有的字段名，_values用于记录一行的所有值。字段名和值是按顺序一一对应的。

例如_keys里面下标为3表示字段名user_email，那么_values里面下标为3的数据就是user_email的值。

正式由于这样一个一一对应的关系，所以row[3]才能实现row['user_email']、row.user_email相同的效果。

回到我们的People类，为了实现相同的目的，我们再次修改代码：

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

class People:
    def __init__(self, name, age):
        self._keys = ['name', 'age']
        self._values = [name, age]
    
    def walk(self):
        print('i am walk')

    def __getitem__(self, key):
        if isinstance(key, int):
            if 0 <= key < len(self._keys):
                return self._values[key]
            return '索引超出边界'

        index = self._keys.index(key)
        if index == -1:
            return 'Key不存在'
        return self._values[index]

    def __getattr__(self, key):
        return self.__getitem__(key)

运行效果如下图所示：

需要说明的是，无论是使用kingname['key']还是kingname[1]，他们都会进入到__getitem__方法中去。

我这里给出的例子相较于records项目的代码做了简化，不过关键的部分都已经囊括了进来。

最后，推荐有兴趣的同学通读records这个项目的源代码，你将会从K大的代码中学到非常多的东西。

如果大家在网上搜索Python 正则表达式，你将会看到大量的垃圾文章会这样写代码：

1
2
3
4
5

import re

pattern = re.compile('正则表达式')
text = '一段字符串'
result = pattern.findall(text)

这些文章的作者，可能是被其他语言的坏习惯影响了，也可能是被其他垃圾文章误导了，不假思索拿来就用。

在Python里面，真的不需要使用re.compile!

为了证明这一点，我们来看Python的源代码。

在PyCharm里面输入:

1
2
3

import re

re.search

然后Windows用户按住键盘上的Ctrl键，鼠标左键点击search，Mac用户按住键盘上的Command键，鼠标左键点击search，PyCharm会自动跳转到Python的re模块。在这里，你会看到我们常用的正则表达式方法，无论是findall还是search还是sub还是match，全部都是这样写的：

1

_compile(pattern, flag).对应的方法(string)

例如：

1
2
3
4
5
6
7
8
9

def findall(pattern, string, flags=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more capturing groups are present in the pattern, return
    a list of groups; this will be a list of tuples if the pattern
    has more than one group.

    Empty matches are included in the result."""
    return _compile(pattern, flags).findall(string)

如下图所示：

然后我们再来看compile：

1
2
3

def compile(pattern, flags=0):
    "Compile a regular expression pattern, returning a Pattern object."
    return _compile(pattern, flags)

如下图所示：

看出问题来了吗？

我们常用的正则表达式方法，都已经自带了compile了！

根本没有必要多此一举先re.compile再调用正则表达式方法。

此时，可能会有人反驳：

如果我有一百万条字符串，使用某一个正则表达式去匹配，那么我可以这样写代码：

1
2
3
4

texts = [包含一百万个字符串的列表]
pattern = re.compile('正则表达式')
for text in texts:
    pattern.search(text)

这个时候，re.compile只执行了1次，而如果你像下面这样写代码：

1
2
3

texts = [包含一百万个字符串的列表]
for text in texts:
    re.search('正则表达式', text)

相当于你在底层对同一个正则表达式执行了100万次re.compile。

Talk is cheap, show me the code.

我们来看源代码，正则表达式re.compile调用的是_compile，我们就去看_compile的源代码，如下图所示：

红框中的代码，说明了_compile自带缓存。它会自动储存最多512条由type(pattern), pattern, flags)组成的Key，只要是同一个正则表达式，同一个flag，那么调用两次_compile时，第二次会直接读取缓存。

综上所述，请你不要再手动调用re.compile了，这是从其他语言（对的，我说的就是Java）带过来的陋习。

我们知道，写Python代码的时候，如果一个包（package）里面的一个模块要导入另一个模块，那么我们可以使用相对导入：

假设当前代码结构如下图所示：

其中test_1是一个包，在util.py里面想导入同一个包里面的read.py中的read函数，那么代码可以写为：

1
2
3
4
5

from .read import read


def util():
    read()

其中的.read表示当前包目录下的read.py文件。此时read.py文件中的内容如下：

1
2

def read():
    print('阅读文件')

通过包外面的main.py运行代码，运行效果如下图所示：

现在，我们增加一个数据文件，data.txt，它的内容如下图所示：

并且想通过read.py去读取这个数据文件并打印出来。

修改read.py，试图使用相对路径来打开这个文件：

1
2
3
4

def read():
    with open('./data.txt', encoding='utf-8') as f:
        text = f.read()
        print(text)

运行代码发现报错：

这个原因很简单，就是如果数据文件的地址写为：./data.txt，那么Python就会从当前工作区文件夹里面寻找data.txt。由于我们运行的是main.py，那么当前工作区就是main.py所在的文件夹，而不是test_1文件夹。所以就会出现找不到文件的情况。

为了解决这个问题，我们有三种解决方式。

• 使用绝对路径

1
2
3
4

def read():
    with open('/Users/kingname/Project/DataFileExample/test_1/data.txt', encoding='utf-8') as f:
        text = f.read()
        print(text)

运行效果如下图所示：

• 先获取read.py文件的绝对路径，再拼接出数据文件的绝对路径：

1
2
3
4
5
6
7
8
9
10

import os


def read():
    basepath = os.path.abspath(__file__)
    folder = os.path.dirname(basepath)
    data_path = os.path.join(folder, 'data.txt')
    with open(data_path, encoding='utf-8') as f:
        text = f.read()
        print(text)

运行效果如下图所示：

• 使用pkgutil库

1
2
3
4
5
6
7

import pkgutil


def read():
    data_bytes = pkgutil.get_data(__package__, 'data.txt')
    data_str = data_bytes.decode()
    print(data_str)

运行效果如下图所示：

pkgutil是Python自带的用于包管理相关操作的库，pkgutil能根据包名找到包里面的数据文件，然后读取为bytes型的数据。如果数据文件内容是字符串，那么直接decode()以后就是正文内容了。

为什么pkgutil读取的数据文件是bytes型的内容而不直接是字符串类型?
这是因为并不是所有数据文件都是字符串，如果某些数据文件是二进制文件或者图片，那么以字符串方式打开就会导致报错。所以为了通用，pkgutil会以bytes型方式读入数据，这相当于open函数的“rb”读取方式。

使用pkgutil还有一个好处，就是只要知道包名就可以找到对应包下面的数据文件，数据文件并不一定要在当前包里面。

例如修改代码结构如下图所示：

另一个包test_2里面有一个数据文件data2.txt。此时如果要在teat_1包的read.py中读取data2.txt中的内容，那么只需要修改pkgutil.get_data的第一个参数为test_2和数据文件的名字即可，运行效果如下图所示：

而前两种方法都不如pkgutil简单。

所以使用pkgutil可以大大简化读取包里面的数据文件的代码。

过去的你只会在代码里消磨每个周末，现在的你有她一起探索生活里的小惊喜；过去的你是一个死宅，现在的你想陪她拿着相机看遍世界的景色。

在Python开发过程中，我们难免会遇到多重条件判断的情况的情况，此时除了用很多的if...elif...else以外，还可以巧用or关键字实现。

例如，我们要获取天气信息，现在有三个api接口。

1
2
3

api_1()
api_2()
api_3()

其中api_1()的数据又详细又好，但是接口不稳定，可能随时会掉线。

api_2()返回的结果比api_1()稍微差一点，但是稳定性还不错。

api_3()接口返回的是兜底数据，就是在前两个接口都故障的情况下才会使用。

如果前两个接口正常工作时返回字典，故障时他们都会返回None。

现在我们要获取天气信息，你可能会这样写代码：

1
2
3
4
5

weather = api_1()
if not weather:
    weather = api_2()
    if not weather:
        weather = api_3()

代码这样写，功能自然是没有问题，但是非常难看。

实际上，代码可以写为：

1

weather = api_1() or api_2() or api_3()

只需要1行代码就能实现自动选择。如果api_1()返回的是一个非空字典，那么由于短路效应，后面的两个函数都不会运行。当api_1返回None时，api_2()才会运行。并且如果api_2()返回非空字典，那么api_3()依然不会运行。

我们现在在Jupyter里面测试一下，首先看看如果api_1()直接返回非空字典的情况，如下图所示。

可以看到，在api_2()和api_3()里面的两行print语句都没有执行。

接下来我们看看api_1()故障时候的情况。

此时先运行api_1()返回None，再运行api_2()返回非空字典。符合预期。

当前两个函数都返回None的时候，第三个函数才会运行，如下图所示。

除了做多重条件判断外，还可以用来自己和自己取或操作，实现重试。

例如api_1()可能成功也可能失败，所以需要尝试运行3次，那么代码可以这样写：

1

weather = api_1() or api_1() or api_1()

我们来投票吧

产品小姐姐召集了项目组的五位开发同学，宣布一项重要的决定。

“作为一个产品，一定要与开发一起对项目有深入的沟通和交流，才能让项目做的更好。所以，今天我们来做一个不记名投票，确定哪几位同学可以和我一起讨论产品的设计方向。”

“现在给到大家的是大老板L叔为大家的产品能力评分，最低1分，最高5分，每人都不一样。大家都只知道自己的得分，互相不知道别人的得分”

“我们的投票规则，是大家一起讨论，不低于几分的人可以和产品一起讨论项目的设计方案。然后独立不记名投赞成票或者反对票”

“首先，1分能力太差，所以不低于2分的人能和产品一起讨论，大家投票。”

“不出所料，1票反对，4票赞成。”

“那分数提高一点，不低于3分的人可以和产品一起讨论项目。大家投票。”

“咦，也是1票反对，4票赞成。”

“那我们看看大于等于4分，才能和产品讨论。”

“也是1票反对4票赞成。”

“那5分呢。”

“还是一票反对，四票赞成。”

“6分呢。”

“还是一票反对，4票赞成。”

“那么好的，经过民主投票，少数服从多数，大多数人都赞成产品能力为6分的人才能跟我一起讨论产品，由于没有人超过6分，所以这个项目我说了算。散会。”

今天又有一个Python初学者被中文技术博客中的垃圾文章给误导了。

这位初学者的问题是：

在Python中，如何精确地进行浮点数的四舍五入，保留两位小数？

如果你经常使用Python的命令行交互环境，你一定遇到过下面这个现象：

1
2
3
4
5

>>> a = 'test'
>>> a
'test'
>>> print(a)
test

首先定义一个变量a，它的值为字符串test。现在，当你在命令行交互环境直接输入变量名再回车的时候，你看到的是'test'，当你输入print(a)的时候，你看到的却是test。

大家在开发Python的过程中，一定会遇到很多反斜杠的问题，很多人被反斜杠的数量搞得头大。

这篇文章，首先会让你越看越糊涂，然后再让你越看越清醒。请坚持看完。