GoCalf Blog - 程序开发

在苹果系统上打造舒服的开发环境

2014-07-26T11:00:00+08:00

用苹果系统已经有一段时间了，越来越喜欢这个系统，不管是一般的使用、做设计、做开发，都非常适合。最近也对系统做了一些调整，使得开发环境更加的舒服，记录下来，免得忘了。

实际的过程是漫长而曲折的，跟下面所写的顺序完全没有关系。如果按照下面的步骤操作，中间难免会遇到一些问题（大多是由于墙导致的），那时再自行 Google 吧。

基础设施

iTerm

对于几乎离不开 shell 的开发者来说，一款优秀的终端程序是基础的基础。

毫无疑问，我用的是 iTerm2。如果说访问互联网世界的入口是 Chrome，那么访问程序世界的入口就是 iTerm 了。

字体选择一款好看的等宽字体即可，比如常用的 Consolas、 Curier New 等。我用的是 Source Code Pro。中文使用 Microsoft YaHei 字体。

配色当然首选 Solarized 的暗色系，在 Github 上可以找到专门提供给 iTerm2 用的配色文件 Solarized Dark.itemcolors。

Homebrew

Homebrew installs the stuff you need that Apple didn't.

我电脑上的大部分工具都是通过 homebrew 安装和管理的，非常方便。虽然提供类似功能的还有 Fink 和 macports，但我认为 Homebrew 是最方便的。具体的就不在这里比较了，大家可以自行调研。当然，至少选择一个来帮助自己安装盒管理软件包，会让很多事情变得更容易。

安装 Homebrew 非常方便，首先要安装 Command Line Tools for Xcode，然后运行

ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"

在使用 Homebrew 的过程中，要注意经常更新它。在 brew 的世界中，24 小时就已经是非常久了。所以在安装某个包或者做其他操作之前，一般都要运行 brew update 和 brew doctor，前者用于更新 Homebrew 自身和各个软件包，后者用于排查可能会遇到的问题。我之前没注意这个（也是因为那时候还没太依赖于 Homebrew），有一次安装一个程序，总是提示我有一个依赖没有装，但那个依赖明明就在那儿，百思不得其解，还跑到 github 上发 issue 去问，被拍了一顿。其实只要 brew update 一下就知道，我安装的那个依赖包太老了，升级了就好了。

在安装某个程序前，我一般也要先 brew info $FORMULA 一下看看，了解一下有没有什么值得注意的参数，安装后有什么需要手动进行的后续操作。

Homebrew 默认会掌控系统中的 /usr/local 目录，目前我这个目录也就只是给 Homebrew 用了，其他的东西都不往里放。在使用 Homebrew 的过程中，一般都避免使用 sudo 进行操作，实际上现在的版本用了 sudo 也就没法使了。

Python

苹果系统自带了好几个版本的 Python，装在 /Library/Python 中。不过版本都不新，为了便于维护，还是自己装一个 Python 吧。用 brew install python 可以安装最新的 Python 2.x，用 brew install python3 可以安装最新的 Python 3.x。

Homebrew 的 Python 已经安装了 pip，用于管理 Python 的软件包。根据 brew info python 提供的提示，运行下列命令对 pip 进行更新：

1 2	pip install --upgrade setuptools pip install --upgrade pip

我现在使用 virtualenv 来管理 Python 的环境，用 virtualenvwrapper 来方便地使用 virtualenv。分别用 pip 进行安装：

1 2	pip install virtualenv pip install virtualenvwrapper

virtualenvwrapper 提供了很多方便的命令，还支持命令的 tab completion，这些都包含在 virtualenvwrapper.sh 文件中。在 ~/.bash_profile 中引入该文件来激活相关的命令和功能：

export VIRTUAL_ENV_DISABLE_PROMPT=1
export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/projects
[ -f "/usr/local/bin/virtualenvwrapper.sh" ] && source "/usr/local/bin/virtualenvwrapper.sh"

准备好后就可以用 mkvirtualenv ENVNAME 来创建一个新的 virtualenv，用 workon 命令来切换环境，用 deactive 退出虚拟环境。更多的命令可以查看 virtualenvwrapper 的文档。

另外，ipython 是非常好用的 Python 的交互式终端，比 Python 自身的命令行提供了更丰富和方便的功能，建议使用。通过 pip install ipython 即可安装。不过目前我还没想清楚要不要把它装在某个虚拟环境中。按理说应该是要在任何一个虚拟环境中都能用 ipython 的，否则就要给每个虚拟环境都装一次，岂不是很浪费空间？这个问题以后再考虑吧。

ipython 除了 shell console 外，还提供 Qt console，详细的信息查看官方的介绍吧。

友好的 Shell

有了 iTerm 还不够，要让 shell 变得好用，还需要再做一些配置。

Bash Profile

~/.bash_profile 的作用就不用我多说了，在这里可以对 shell 进行很多的个性化配置。参考 mathiasbynens 的 dotfiles 项目，我也为自己打造了舒适的 shell 环境，相关的配置保存在 GitHub - calfzhou - dotfiles - bash 里面，对 Mac 和 Linux 都是可以的，让我在不同的服务器上也有相同的操作体验。涉及到的内容很多，就不逐一介绍了，比较重要的几点下面会提到。

Dir Colors

虽然 iTerm 本身已经设置好了 Solarized 配色，但是 ls 的时候并不一定有颜色。ls 没有颜色绝对是让人难以忍受的，在 bash_inc/alias 里除了根据系统中 ls 支持的参数让 ls 的输出显示出颜色外，还通过配置 LS_COLOR 让色彩更丰富，可以让不同类型的文件有不同的颜色，看起来非常的清晰。推荐使用 dircolors-solarized 提供的配色文件，在 Mac OS X 的采用了 Solarized Dark 配色的 iTerm2 里看起来会是这个样子：

iTerm2 中 Solarized Dark 系的 dircolors 效果

Bash Prompt

在使用 shell 的过程中，命令提示符会一直陪伴着我们，是时候扔掉默认的提示符了。我的命令提示符用不同的颜色分别显示出当前时刻、当前用户、当前主机（通过颜色标识是否通过是通过 SSH 登录的）、当前使用的 Python virtualenv（如果有的话）、当前目录、当前目录所在的 git 分支和状态（如果是 git 项目的目录的话）。

关于主机名，Mac 系统下默认应该是 localhost，可以通过 scutil 命令修改成想要的值：

1
2
3

$ sudo scutil --set HostName MYNAME
$ hostname
MYNAME

配合上 iTerm 的配色、ls 的颜色等，我的 shell 看起来是这样的：

我的 iTerm2 的效果

Bash Completion

在 shell 里面输入命令的时候，如果只记得开头几个字母，后面的记不清楚了也没关系，输入几个字母后，按 TAB 键就可以自动补全或者提示出所有可行的命令。在输入文件名的时候也可以通过 TAB 键自动补全或者提示出有效的文件文来，这个功能是非常方便的。Homebrew 又额外提供了一些 bash completion 功能，可以通过 brew install bash-completion 进行安装，并会生成 /usr/local/etc/bash_completion 文件，在 ~/.bash_profile 中 source 一下这个文件，就可以把 Homebrew 提供的命令补全包含进来。如果通过 Homebrew 安装了别的工具包，比如 git、svn 等，它们也会有各自相应的命令补全文件，存放在 /usr/local/etc/bash_completion.d 目录中，都会被刚才那个文件自动引入。

Shell Commands

用惯了 Linux（CentOS）里面的 shell 命令，就无法忍受 Mac 系统中那些落后的 shell 命令了，像 ls、date、ps、echo、grep 等等，功能都特别少。在忍无可忍之后，终于决定用 GNU Coreutils 替换它们。用 brew install coreutils 就可以搞定了，安装完成后，根据提示，将 /usr/local/opt/coreutils/libexec/gnubin 和 /usr/local/opt/coreutils/libexec/gnuman 分别添加到 $PATH 和 $MANPATH 中即可。

grep 命令不在 coreutils，可以通过 brew install grep --default-names 搞定（如果说找不到 grep 可以先 brew tap homebrew/dupes）。当然还有很多其他特别有用的命令，就不一一细说了，反正想到什么，只要用 brew info 或者 brew search 找找看就行。

编辑器和 IDE

VIM

其实我也不是 VIM 重度使用者，现在写超过两个文件的 Python 代码、Java 代码等都会使用专门的 IDE。我看很多人都喜欢用 VIM 来写复杂的项目代码，但他们的 VIM 都没有做任何额外的设置，自身对 VIM 的快捷键和命令也不熟悉，只是把 VIM 当成一个连移动光标都很费劲的编辑器来用，写代码的效率可想而知。而且像 Python 这种脚本语言，很多错误只有到运行到那句话的时候才会有效果，VIM 没有足够的只能针对某一个语言做太多的静态分析。

~/.vimrc 用于对 VIM 进行各种设置，如果没有这个文件，赶紧创建一个吧。复杂的语法高亮、配色、插件等都可以放在 ~/.vim 里面。VIM 自身对插件没有很好地管理，我选择了 vim-pathogen 来管理所需要的 VIM 扩展。只要把 pathogen.vim 放在 ~/.vim/autoload 目录中，把所需的扩展包放在 ~/.vim/bundle 目录下即可。

同样地，我也把自己的 VIM 设置和依赖放在 GitHub 上（GitHub - calfzhou - dotfiles - vim），在别的 server 上直接 clone 下来保持一致的操作体验。

我现在使用 riv.vim 扩展来写 reStructuredText 文件（.rst），操作起来非常方便。

如果不满意苹果系统自带的较低版本的 VIM，或者想用 GUI 界面的 VIM，可以利用 Homebrew 进行安装，Formula 是 vim 和 macvim。

Sublime Text

Sublime Text 是我现在主要使用的 GUI 编辑器，但看其首页的动画演示就会觉得非常 cool。以前还经常用 Ultra Edit 和 Notepad++，现在基本都不用了。在 GUI 程序中，我一般会使用 Solarized Light 配色方案，总感觉大部分 GUI 程序用暗色系就很丑（PyCharm 系列除外）。

具体的配置也就不多说了。注意 Sublime Text 原生不支持 GBK 编码的文件，需要安装扩展包，即使这样，在编辑 GBK 编码的文件时，它会生成一个临时文件进行操作，保存的时候再写回去，体验上还是有些不爽。

还有一个地方我也一直没搞清楚，就是中文字体不是刚刚好跟两个英文字母一样宽。在编辑 reStructuredText 文件的时候，还是会比较麻烦的。

Python IDE

以前一直用 VIM 做 Python 开发，是因为没找到好用的 Python IDE，现在我用 JetBrains 出的 PyCharm。不要跟我争，这绝对是世界上最好用的 Python IDE，没有之一。

PyCharm 里强烈推荐自带的 Darcula 配色，感觉在 GUI 界面中，这个配色比 Solarized Dark 要舒服一些。PyCharm 的默认配置基本就很好用了，它对 Python 代码的可读性检测方面要求还是比较严格的，空行、空格不合适都会有提示。如果 Python 项目中包含其他类型的文件（如 shell 脚本、html 页面等），它也有相应的插件可以对这些文件进行语法高亮。

一直觉得如果 JetBrains 出一个通用的编辑器，应该能把 Sublime Text 甩出好几条街去。

Java IDE

好多人都用 Eclipse 写 Java 代码（包括 Android 开发），真想不通为什么那么难用的 IDE 还那么受欢迎。可能学校里交 Java 的时候都用的 Eclipse 吧，就像直到现在都还有很多人用 VS6 做 C++ 开发一样。对于 Android 开发，可能跟之前 Google 推 Eclipse with ADT 有关吧。不过现在 Google 也认识到了 Eclipse 的不足，转身投入 JetBrains 的 IntelliJ IDEA 的怀抱了。JetBrains 出品的个个都是精品啊，微软里面很多项目组也都在使用 JetBrains 出的 ReSharper。

我现在也是用 IntelliJ IDEA 来做 Java 开发，使用体验跟 PyCharm 类似。Java 项目的依赖管理用 Maven，Homebrew 里也提供了安装。建议目前使用 Maven 3.0.*：

1 2	brew tap homebrew/versions brew install maven30

当然如果要用最新的 3.2.*，可以直接 brew install maven。

版本控制

Git

用 Homebrew 可以方便地安装最新的 Git。如果像上面介绍的那样，用 Homebrew 安装并使用了 bash-completion，那么装好 git 后，git 指令也会按 TAB 键补全了，再也不动担心记不住 git 指令。

~/.gitconfig 可以用来定义很多个性化的设置，可以直接编辑或者通过 git config --global 进行设置。类似的，我也把我的配置文件保存在 GitHub 上（GitHub - calfzhou - dotfiles - git），以便在不同的地方有同样的操作体验。

顺便提一下，用 git 管理项目版本的话，推荐使用 git-flow 管理分支和版本，通过 Homebrew 可以直接安装它，同样也会带有 TAB 自动补全功能。关于这种分支管理的模型，可以阅读 A successful Git branching model。

如果想在公开的 git 仓库中保存一些比较隐私的信息，可以利用 git-encrypt 来加密其中的一部分文件。这个也可以直接通过 Homebrew 安装。大致的介绍在之前的文章用 Git 和云存储保存隐私信息中略有介绍。

如果还想用个 GUI 的 Git 客户端，我用的是 GitX-dev，主要用来直观地观察分支的演化情况。

GitX-dev 界面演示

SVN

用了 Git，就再也不想用 SVN 了。不过有时候也难免会需要用，用 Homebrew 安装个新版本的 SVN 吧，同样也会有 TAB 键补全哦。

将整数数字转换成中文

2014-01-28T09:30:00+08:00

今天来看一个简单的程序开发问题，（用 Python）编写一段程序，将一个任意给定的整数（可正可负）转换成对应的中文读法。比如输入数字 -12345，输出字符串“负一万二千三百四十五”。

同时也会稍微涉及到数据驱动的测试（data driven test）。

Note

实际上，对于同一个数字，用中文的读法可能不唯一，在不同的场合也可能会有不同的习惯。我这里采用 Google 拼音输入法提供的读法。

准备工作

基本的方法很简单，从高位到低位依次把每个数字映射成对应的汉字，再把位数对应的汉字加上就可以了。如果是负数，则在前面加一个“负”即可。

先把用中文读一个数字所需要的汉字都找出来，它们是“负零一二三四五六七八九十百千万亿兆”等。注意这里的“兆”表示 10 的 12 次方，而不是计算机领域的 10 的 6 次方。在开始之前，先要把这些汉字分分类，比如一二三四之间的差异跟十百千就不一样，跟万亿兆也不一样。

最特殊的字是“负”，用一个单独的常量保存它。

然后是“零”。在计数体系中，“零”跟其他数字可是有着本质区别的，在中文表达的时候，这种特殊性也非常明显，所以也单独分配一个常量。

数字“一二三四五六七八九”是十进制数字中，除零之外的基本字符，对应了除“0”之外的全部九个阿拉伯数字符号。用一个常量数组保存。它们的特点是构成了一个差值为 1 的等差数列。

“十百千”是每个万组内的数位标识，是一个比值为 10 的等比数列。在这里大家可以看出为什么不把“十”跟上一组汉字放在一起。

最后是“万亿兆”，是比值为 10^4 的等比数列。实际上后面还可以继续写下去（参见个十百千万亿兆后面是什么），比如 10^16 用“京”表示，再往后依次是“垓”、“杼”、“穰”、“溝”、“澗”、“正”、“載”、“極”（10^48）。如果还要写下去，还有“恆河沙”、“阿僧祇”、“那由他”、“不可思議”、“無量”、“大數”（10^72）。这种计数体系称为中法，是万进系统，以万递进。当然扯远了，程序中我们只用到“兆”，如果想要支持后面的字，只要修改常量就可以，对程序逻辑没有影响（除非要修改计数体系）。

又啰嗦了。看一下这部分的代码（Python 2.7.x）。

# -*- coding: utf-8 -*-

CHINESE_NEGATIVE = '负'
CHINESE_ZERO = '零'
CHINESE_DIGITS = ['', '一', '二', '三', '四', '五', '六', '七', '八', '九']
CHINESE_UNITS = ['', '十', '百', '千']
CHINESE_GROUP_UNITS = ['', '万', '亿', '兆']

初始版本

常量定义好之后，就先写个最简单的处理方法。负数和零就不多说了，只看正数的情况。

比如数字是 12345，输出应该是“一万二千三百四十五”，在这种最普通的情况下，操作方法就是把每个数字对应的汉字和该数位所对应的汉字拼在一起，然后每个万组还要加上该万组的单位（即“万亿兆”）。

因此首先需要从高位到低位枚举每一位数字，要同时知道数字和对应的数位（比如个位是 0，十亿位是 9，等等）。下面这段简单的程序是从低位开始枚举，使用的时候只要反转（reverse）一下就可以了。

def _enumerate_digits(number):
"""
:type number: int|long
:rtype: collections.Iterable[int, int]
"""
position = 0
while number > 0:
    digit = number % 10
    number //= 10
    yield position, digit
    position += 1

然后来写第一个版本的目标函数，translate_number_to_chinese。

def translate_number_to_chinese(number):
"""
:type number: int|long
:rtype: string
"""
if not isinstance(number, int) and not isinstance(number, long):
    raise ValueError('number must be integer')

if number == 0:
    return CHINESE_ZERO

words = []

if number < 0:
    words.append(CHINESE_NEGATIVE)
    number = -number

# Begin core loop.
# Version 0.1
for position, digit in reversed(list(_enumerate_digits(number))):
    unit = position % len(CHINESE_UNITS)
    group = position // len(CHINESE_UNITS)

    if digit != 0:
        words.append(CHINESE_DIGITS[digit])
        words.append(CHINESE_UNITS[unit])

    if unit == 0:
        words.append(CHINESE_GROUP_UNITS[group])

# End core loop.

return ''.join(words)

啊，由于工作原因，代码风格有所调整。以前在 Python 里函数名采用驼峰方式，首字母大写。现在改用小写加下划线了。

单元测试

显然上面的代码是有问题的，比如如果数字中有 0，有些结果就不太对。对于 11 到 19 的处理也有问题。因此需要做单元测试，多准备各种情况的测试用例尽可能覆盖更多的特殊情况。

这里不详细说怎么创建和编写单元测试，只说一下数据驱动的测试（Data Driven Test）。

一般在 Python 里写单元测试，比如想测试一下输入 10 时，程序输出是否正确。那就添加一个测试方法（test method），调用函数得到实际的输出值（现在应该是“一十”），跟期望的输出（应该是“十”）作比较。

这样做的缺点是，如果想增加一个用例，就要添加一段代码，而新添加的代码整个逻辑是一样的，只是其中的输入和期望输出变了，代码重复度太高，而且也太麻烦了。

对于这种情况会比较多的测试，一般会把各种需要测试的输入和期望输出写在一个数据文件里。于是可以在测试方法中读入文件中的每一组数据，用 for 循环依次进行测试。如果所有的测试用例都能成功也就没什么问题，但如果有些用例会失败，一旦某个用例失败，测试方法就会停止，后面的数据就不会再被测到。这样每次都只能看到第一个出现的错误，无法得到完整的测试结果。在改 bug 的时候，也很容易出现按住葫芦浮起瓢的事情。

以前用 C# 的时候，做数据驱动的测试非常方便，只要给测试方法添加 DataSource Attribute 就可以了。在 Python 里没有发现直接的方法，不过可以自己写一个简单的函数来处理，原理就是用数据文件中的每一个测试用例给测试类动态添加一个测试方法。

# -*- coding: utf-8 -*-
from unittest import TestCase
from foo import translate_number_to_chinese


class TestTranslateNumberToChinese(TestCase):
    pass


def create_number_test_function(number, expected):
    def _test_method(self):
        actual = translate_number_to_chinese(number)
        print actual, expected
        self.assertEqual(actual, expected)

    return _test_method


def add_tests():
    number_data_path = 'number_data.txt'
    with open(number_data_path) as data_file:
        for line in data_file:
            line = line.rstrip('\r\n')
            number_text, expected = line.split('\t')
            number = int(number_text)
            setattr(TestTranslateNumberToChinese, 'test_number_{}'.format(number),
                    create_number_test_function(number, expected))

add_tests()

上面的示意中，假设测试用例保存在一个叫做“number_data.txt” 的 TSV 文件中。每行用 TAB 分割为两列，分别是阿拉伯数字和期望的中文读法。

“add_tests”方法对每一个测试用例，调用“create_number_test_function”创建一个测试方法，添加到测试类“TestTranslateNumberToChinese”中。

假设这段测试代码所在的文件叫做“test_translate_number_to_chinese.py”，那么在命令行运行如下命令就可以把所有的测试用例都测一遍。

1	python -m unittest test_translate_number_to_chinese

大刀阔斧进行修改

准备好测试方法和足够的测试用例后，就可以放心地对代码进行修改了。每次修改一点儿，都可以跑一下单元测试，看看又成功或者失败了几个用例，总结出规律，继续改进。

特殊的“0”

目前主要的问题在于对“0”的处理上，上面的程序忽略了所有的“0”。

实际上，在一个万组内，末尾所有连续的“0”都不用读，如 500：五百、20：二十。这方面刚好上面的代码就是这样处理的。注意这个规则不仅仅针对数字最末尾的“0”，而是对每一个万组都有效的。比如 2005678：二百万五千六百七十八（不加“零”）。

在一个万组内，如果两个非零数字之间有一个或者多个“0”，都需要（且只需要）读一个“零”。如 201：二百零一、3006：三千零六、1020：一千零二十。

一个万组内，如果高位数字是 0，那么是否需要读出来就看更高的万组是什么情况了。如果没有更高的万组，就不用读，否则就需要。比如 0200（实际上首位的 0 就不出现了）：二百、10200：一万零二百。

添加两个局部变量来记录一下状态，一个是“group_is_zero”记录当前处理的万组是否仍然是全 0，另一个是“need_zero”记录是否需要添加一个“零”。

把上面 translate_number_to_chinese 中的 core loop 修改一下，得到：

# Begin core loop.
# Version 0.2
group_is_zero = True
need_zero = False
for position, digit in reversed(list(_enumerate_digits(number))):
    unit = position % len(CHINESE_UNITS)
    group = position // len(CHINESE_UNITS)

    if digit != 0:
        if need_zero:
            words.append(CHINESE_ZERO)

        words.append(CHINESE_DIGITS[digit])
        words.append(CHINESE_UNITS[unit])

    group_is_zero = group_is_zero and digit == 0

    if unit == 0:
        words.append(CHINESE_GROUP_UNITS[group])

    need_zero = (digit == 0 and (unit != 0 or group_is_zero))

    if unit == 0:
        group_is_zero = True

# End core loop.

全零的万组

接下来遇到的问题是，如果一个万组完全是 0，就不要再添加对应的单位了，比如 100000000：一亿（现在会输出“一亿万”）。

解决方法很简单，把上面的 if unit == 0: 改成 if unit == 0 and not group_is_zero: 即可。完整代码略。

麻烦的“1”

最后一种特殊的情况是由数字“1”引起的。

在一个万组内，如果千位和百位都是“0”，十位是“1”，那么这个“一”就不用读出来，比如 10：十、14：十四。

但如果千位或者百位不是“0”，这个“一”就需要读出来，比如 213：二百一十三、2013：二千零一十三。

当更高的万组存在时，即使当前万组的千位和百位都为“0”，也需要读出“一”，比如 20010：二万零一十。

解决的方法是在上面的 words.append(CHINESE_DIGITS[digit]) 前面增加条件：

1	if digit != 1 or unit != 1 or not group_is_zero or (group == 0 and need_zero):

最后完整的 core loop 代码为：

# Begin core loop.
# Version 0.4
group_is_zero = True
need_zero = False
for position, digit in reversed(list(_enumerate_digits(number))):
    unit = position % len(CHINESE_UNITS)
    group = position // len(CHINESE_UNITS)

    if digit != 0:
        if need_zero:
            words.append(CHINESE_ZERO)

        if digit != 1 or unit != 1 or not group_is_zero or (group == 0 and need_zero):
            words.append(CHINESE_DIGITS[digit])

        words.append(CHINESE_UNITS[unit])

    group_is_zero = group_is_zero and digit == 0

    if unit == 0 and not group_is_zero:
        words.append(CHINESE_GROUP_UNITS[group])

    need_zero = (digit == 0 and (unit != 0 or group_is_zero))

    if unit == 0:
        group_is_zero = True

# End core loop.

试试看

代码介绍完了，下面放一个用 JavaScript 实现的版本，可以随便输入一些数字试试看。源代码参见 http://jsfiddle.net/calfzhou/tGEz7/。

用 Python 读写 Excel 文件

2013-12-03T20:50:00+08:00

虽然天天跟数据打交道，也频繁地使用 Excel 进行一些简单的数据处理和展示，但长期以来总是小心地避免用 Python 直接读写 Excel 文件。通常我都是把数据保存为以 TAB 分割的文本文件（TSV），再在 Excel 中进行导入或者直接复制粘贴。

前段时间做一个项目，却不得不使用 Python 直接生成 Excel 文件，后来随着需求的变化，还要对已有的 Excel 文件进行读取。在这个过程中，研究并尝试了一些工具，也走了一些弯路。记录下来，下次再有类似需求的时候就不用漫天遍野地搜索了。

超级无敌大 PK

我主要尝试了四种工具，在此并不会给出他们的排名，因为在不同的应用场景下，做出的选择会不同。

	XlsxWriter	xlrd&xlwt	OpenPyXL	Microsoft Excel API
介绍	可以创建 Excel 2007 或更高版本的 XLSX 文件	即 python-excel，含 xlrd、xlwt 和 xlutils 三大模块，分别提供读、写和其他功能	可以读写 Excel 2007 XLSX 和 XLSM 文件	直接通过 COM 组件与Microsoft Excel 进程通信，调用其各种功能实现对 Excel 文件的操作
读	❌	✅	✅	✅
写	✅	✅	✅	✅
修改	❌	❌	⚠️	✅
.xls	❌	✅	❌	✅
.xlsx	✅	⚠️	✅	✅
大文件	✅	❌	✅	❌
功能	强	弱	一般	超强
速度	快	快	快	超慢
系统	无限制	无限制	无限制	Windows + Excel
使用场景	要创建 XLSX 文件不需要读取已有文件需要实现比较复杂的功能数据量可能会很大需要跨平台	要读取 XLS 或 XLSX 文件要生成 XLS 文件需要的功能不太复杂需要跨平台	要处理 XLSX 文件需要修改已有文件，或者在写入过程中需要不断修改需要的功能比较复杂数据量可能会很大需要跨平台	需要处理各种文件格式需要用到特别复杂的功能在修改文件时，不希望对原有信息造成任何意外破坏数据量很小，或者愿意等待仅在 Windows 中使用

XlsxWriter

XlsxWriter 是我最终选择的用于写操作的工具。顾名思义，它只能用来写文件。

这应该是个比较新的项目，在 GitHub 上看它最早的提交是在 2013 年 1 月份。其官方文档中宣称它支持：

100% compatible Excel XLSX files.
Full formatting.
Merged cells.
Defined names.
Charts.
Autofilters.
Data validation and drop down lists.
Conditional formatting.
Worksheet PNG/JPEG images.
Rich multi-format strings.
Cell comments.
Memory optimisation mode for writing large files.

优点

一、功能比较强

相对而言，这是除 Excel 自身之外功能最强的工具了。比如我就用到了它提供的：字体设置、前景色背景色、border 设置、视图缩放（zoom）、单元格合并、autofilter、freeze panes、公式、data validation、单元格注释、行高和列宽设置等等。

最让我惊奇的是，用它生成的带有单元格注释的 Excel 文件，不论是 Excel 2007 还是 Excel 2013 都可正常打开（下面会提到，这个任务用 Excel 自身都无法完成）。

二、支持大文件写入

如果数据量非常大，可以启用 constant memory 模式，这是一种顺序写入模式，得到一行数据就立刻写入一行，而不会把所有的数据都保持在内存中。

缺点

一、不支持读取和修改

作者并没有打算做一个 XlsxReader 来提供读取操作。不能读取，也就无从修改了。它只能用来创建新的文件。我是利用 xlrd 把需要的信息读入后，用 XlsxWriter 创建全新的文件。

另外，即使是创建到一半 Excel 文件，也是无法读取已经创建出来的内容的（信息应该在，但是并没有相应的接口）。因为它的主要方法是 write 而不是 set。当你在某个单元格写入数据后，除非你自己保存了相关的内容，否则还是没有办法读出已经写入的信息。从这个角度看，你无法做到读出 -> 修改 -> 写回，只能是写入 -> 写入 -> 写入。

二、不支持 XLS 文件

XLS 是 Office 2013 或更早版本所使用的格式，是一种二进制格式的文件。XLSX 则是用一系列 XML 文件组成的（最后的 X 代表了 XML）一个压缩包。如果非要创建低版本的 XLS 文件，就请移步 xlwt 吧。

三、暂时不支持透视表（Pivot Table）

透视表是非常麻烦的东西，除了自身复杂的结构外，还需要一套数据缓存。我向作者提出了这个需求，不过这是个很难完全实现的功能，我们慢慢期待吧。

xlrd&xlwt

我的程序在第一版的时候，使用 xlwt 创建 XLS 文件，然后通过 Microsoft Excel API 将其转换为 XLSX 文件，并写入高级的 Data Validation（Excel 2007 的 Data Validation 比 Excel 2003 要强大不少）和单元格注释。

我的程序最终的版本也依然用 xlrd 从已有的文件中读出所需的信息。

xlrd&xlwt 主要是针对 Office 2013 或更早版本的 XLS 文件格式。

优点

一、支持 XLS 格式

XlsxWriter 和 OpenPyXL 都不支持 XLS 格式，从这个角度看，xlrd&xlwt 仍然有一定的不可替代性。

缺点

一、对 XLSX 支持比较差

目前 xlrd 已经可以读取 XLSX 文件了，有限地支持。至于 xlwt 我没有试验过，估计是够呛。

二、对修改的支持比较差

xlrd 和 xlwt 是两个相对独立的模块，虽然 xlutils 提供方法帮助你把 xlrd.Book 对象复制到 xlwt.Workbook 对象，但跟 XlsxWriter 类似，后者只是提供 write 方法，使得你无法很容易地获取当前已经写入的数据并进行有针对性的修改。如果非要这样做，你要不断地保存，然后再用新的 xlrd.Book 对象读取你要的信息，还是比较麻烦的。

三、功能很弱

除了最基本的写入数据和公式，xlwt 所提供的功能非常少（Excel 2013 本身支持的功能也就很少）。对于读取也是一样的，很多信息在读入时就丢失掉了。

OpenPyXL

OpenPyXL 是比较综合的一个工具，能读能写能修改，功能还算可以但也有很大的缺陷。我在中间版本的时候是打算完全依赖它的，但后来发现一个严重的问题就放弃了。

优点

一、能读能写能修改

OpenPyXL 的工作模式跟 XlsxWriter 和 xlwt 有很大的区别，它用的是 getter/setter 模式。你可以随时读取某个单元格的内容，并根据其内容进行相应的修改，OpenPyXL 会帮你记住每个单元格的状态。

特别需要注意的一点：虽然它支持修改已有文件，但由于其所支持的功能有限，读入文件时会忽略掉它所不支持的内容，再写入时，这些内容就丢失了。因此使用时一定要慎重。比如下面的缺点中提到它无法读入公式，那如果你修改一个带有公式的文件，保存之后，所有的公式就都没有了。

二、功能还算可以

整体来讲，它所支持的功能介于 XlsxWriter 和 xlwt 之间。

缺点

一、不支持 XLS

这件事情只能让 xlrd 和 xlwt 去做。

二、不支持读取公式

这其实是个不太简单的事情，虽然我没尝试过，但相信 xlrd 也做不好这件事。

Excel 的单元格如果是一个公式，它内部会同时保存公式本身和运算结果的缓存。用 OpenPyXL 读取单元格内容，它不会告诉你这个单元格的公式是什么，甚至不会告诉你这个单元格存的是公式，它只会拿到这个缓存的运算结果。我本来想利用它判别单元格是不是用了公式，然后做出不同的处理。结果遇到了这个问题，最后只好采取了其他变通的方式去做。

Microsoft Excel API

大部分 Windows 环境的开发人员都会选择 Microsoft Excel API。实际上不仅仅是 Python，几乎各种语言都有相应的方法使用它，因为核心的逻辑完全是由 Microsft Excel 自身提供的。语言相关的部分只是负责跟 Windows 的 COM 组件进行通信。

在 Python 中首先需要安装 Python for Windows extensions（pywin32），具体的文档可以查阅 Win32 Modules 和 Python COM。

当然你还必须要安装某一个版本的 Microsoft Office Excel，它内部的 DLL 负责实际的操作。

优点

一、最大的优点：强大无极限

因为直接与 Excel 进程通信，你可以做任何在 Excel 里可以做的事情。

二、文档丰富

MSDN 上的文档绝对是世界上最优秀的文档。没有之一。

三、调试方便

你完全可以直接在 Excel 里面用宏先调试你想要的效果。甚至如果你不清楚怎么用程序实现某个操作，你可以通过宏录制的方法得到该操作的处理代码。

缺点

一、致命的缺点：慢到死

因为需要与 Excel 进程通信，其效率是非常低的。

如果让 Excel 窗口可见，随着程序的运行，你可以看到每一句程序所带来的变化，单元格的内容一个一个地改变。如果要写入的数据很多，那速度是无法忍受的。

二、平台限制

目前还没有发现可以在非 Windows 系统使用它的方法。

另外，基于它的程序能做什么事情，很大程度上依赖于当前系统所安装的 Excel 版本。不同的版本在功能上有很大的差异，API 也会有差异。用起来会比较麻烦。

三、Excel 自身 bug 导致的问题

我刚好发现了其中一个，这和 Python 没有任何关系，可以完全在 Excel 中手动复现。在 Excel 2007 中随便创建一个文件，给某个单元格添加注释，保存。换台电脑，用 Excel 2013 打开，就会报错，然后注释就消失了。

同样如果你的程序在一台装有 Excel 2007 的机器上创建一个带有注释的 Excel 文件，把这个文件拿到 Excel 2013 中打开也会报错，也看不到注释。反过来也一样。

关于初始化

Excel 的 com 接口的具体细节我就不介绍了，需要的话直接查阅相关的 MSDN 文档即可。这里只提几个特殊的小问题。

要想得到一个可以操作的 excel 对象，一般可以有两种方式：

import win32com.client

excel = win32com.client.Dispatch('Excel.Application')

import win32com.client

excel = win32com.client.DispatchEx('Excel.Application')

二者的区别在于，Dispatch 方法会试图寻找并复用一个已有的 Excel 进程（比如你已经在运行着的 Excel 程序），而 DispatchEx 则一定会创建一个新的 Excel 进程。一般情况使用前者就可以了，还能节省一些资源的开销。但也会带来一些麻烦，有一些状态是在一个 Excel 进程内共享的，你在同进程的其他窗口内操作有可能会影响到 Python 程序所要进行的处理，导致各种错误。比如当你手动开启的 Excel 窗口中，某个单元格正处于编辑状态，那 Python 程序控制的大部分操作都有可能失败（即使它操作的是另一个文件），因为一个 Excel 进程中无法让两个单元格同时被编辑。

为了避免麻烦，我一般都使用 DispatchEx 方法。

关于窗口可见

可以让新启动的 Excel 进程窗口可见，就像你通过双击桌面上的图标启动一样，程序所控制的每一步操作，在这个窗口中都可以观察得到。你也可以同时进行手动的操作，但一旦这样做，很有可能使你的 Python 程序崩溃。

窗口不可见也会带来一些麻烦，前面说了，通过 Python 启动的 Excel 进程跟你直接从桌面打开的 Excel 进程没有什么区别，在使用 Excel 的过程中，我们经常会遇到各种弹出的错误、警告或者提示框，这些在用 Python 处理时也有可能遇到。尤其当你的程序还没完全调试好时。

我一般都会让程序控制的 Excel 进程在调试过程中可见，正式使用时不可见，通过类似这样的命令（假设你有一个叫做 is_debug 的变量记录当前是否在调试状态）：

excel = win32com.client.DispatchEx('Excel.Application')
if is_debug:
    excel.Visible = True

关于保存并覆盖已有文件

打开和保存文件的细节不在这里多说了，可以查看 MSDN 中相关的 API 介绍，非常详细。这里只说一下在另存为时，如果目标文件已经存在怎么办。Excel 的 API 另存为方法似乎并没有提供参数决定是否直接覆盖同名的目标文件，在窗口操作中，这种情况会弹出一个确认框来让用户决定。我们的程序当然不想这么做，实际上如果你按照上面所说的让窗口不可见，你也就看不到弹出的窗口。

可以把 DisplayAlert 属性关闭，这样 Excel 就不会弹出确认窗，而是直接覆盖同名文件。

orig_display_alerts = excel.DisplayAlerts
excel.DisplayAlerts = False
try:
    book.SaveAs(save_as_file_path)
finally:
    excel.DisplayAlerts = orig_display_alerts

关于结束 Excel 进程

进程是一种资源，我们申请了资源，在用完之后就必须要释放掉。尤其如果你隐藏了 Excel 窗口，用户只有查看系统进程，否则无法关闭你所开启的进程。

但是一个 Excel 进程是可以同时开启多个文件的，这些文件可能是你程序的其他部分开启的，也可能是用户自己开启的。这样你就不能随意地结束 Excel 进程，否则会影响到其他人或程序的操作。

我一般会在我的处理完成后（关闭了我自己打开或者创建的 Excel 文件），判断一下当前 Excel 进程是否还开启着其他的文档，如果没有了才会结束该进程。

number_of_workbooks = excel.Workbooks.Count
if number_of_workbooks > 0:
    logging.debug(
        'there are still %d workbooks opened in excel process, not quit excel application',
        number_of_workbooks
    )
else:
    logging.debug(
        'no workbook opened in excel process, quiting excel application instance ...'
    )
    excel.Quit()

del excel

关于枚举常量

Excel API 中有各种各样的枚举常量，我还没有找到在 Python 中直接引用这些常量的方法，目前的办法是找到所需的常数的值，自己定义这些常数。比如我用到了如下这些枚举常量：

class ExcelConstants(object):
    # XlFileFormat Enumeration
    xlOpenXMLWorkbook = 51  # Open XML Workbook.

    # XlDVType Enumeration
    xlValidateList = 3  # Value must be present in a specified list.

    # XlDVAlertStyle Enumeration
    xlValidAlertStop = 1  # Stop icon.

    # Constants Enumeration
    xlCenter = -4108

    # XlLineStyle enumeration
    xlContinuous = 1

要想知道某一个枚举常量的数值，可以查阅 MSDN 中 Excel Enumerations 相关的资料。

【2014 年 7 月 31 日更新】感谢 @依云提醒，在 Python 也能够直接引用相关的常量，即通过 win32com.client.constants 获取常量的值。不过这里还有一点比较 tricky 的地方，如果直接用 Dispatch 或者 DispatchEx 得到 Excel 对象，是无法从 constants 中取出常量值的，需要手动运行 makepy，或者通过 win32com.client.gencache.EnsureDispatch 获得 Excel 对象：

import win32com
from win32com.client import constants
excel = win32com.client.gencache.EnsureDispatch('Excel.Application')
print constants.xlOpenXMLWorkbook  # will be 51
print constants.xlCenter  # will be -4108

iOS 可拉伸的图片

2012-03-10T22:57:00+08:00

还记得在 Windows 下用 MFC 或 WTL 写用户界面程序的时候，为了给可改变大小的对话框加上背景图案，需要对设计师提供的图片进行裁剪。把图片切成九块，其中四个角是不拉伸的，四条棱边可以在一个方向上拉伸，中间区域则可任意拉伸。其过程是相当烦琐的。在 Mac 下，一切都变的及其简单，UIImage 类已经为我们提供了处理拉伸的方法。

以下内容适用于 iOS 2.0+，或在 iOS 5.0 + 中使用替换的方法。

UIImage 有一个叫做端帽（end cap）的概念，利用它来指定图片中哪一部分（通常在图片的中央）是可以拉伸的，哪些部分（四周一圈）不可拉伸。在 iOS 5.0 以前，通过 stretchableImageWithLeftCapWidth:topCapHeight: 来得到可以按照指定方式拉伸的图片。特别要注意的一点，我在第一次用它的时候没有注意到，就是这个方法并不会改变当前的 UIImage 实例，而是会返回一个新的实例。这样的设计可能是为了让通过 imageNamed 方法得到的 UIImage 实例能够最大限度地复用吧。

stretchableImage 方法有两个整数参数，分别用来指定图片的左边和上边分别有多少点（points）是不能被拉伸的（端帽宽度）。并没有参数用来指定右边和下边的端帽宽度，开始我误以为右边和下边的端帽宽度就分别等于左边和上边的端帽宽度，然而仔细阅读官方文档之后发现并非如此：

The middle (stretchable) portion is assumed to be 1 pixel wide. The right end cap is therefore computed by adding the size of the left end cap and the middle portion together and then subtracting that value from the width of the image:
rightCapWidth = image.size.width - (image.leftCapWidth + 1);
The middle (stretchable) portion is assumed to be 1 pixel wide. The bottom end cap is therefore computed by adding the size of the top end cap and the middle portion together and then subtracting that value from the height of the image:
bottomCapHeight = image.size.height - (image.topCapHeight + 1);

原来已经规定了中间可拉伸区域必须是 1x1 的，因此右边和下边的端帽宽度就由图片的宽度和高度、左边和上边的端帽宽度决定。在设计非对称图案时需要注意一下。

从 iOS 5.0 开始，stretchableImage 方法被弃用，取而代之的是 resizableImageWithCapInsets:。后者只需要一个 UIEdgeInsets 类型的参数，通过此参数，可以设置四个端帽的宽度。而中心剩余的部分都是可以拉伸的（不再局限于 1x1 大小）。

下面这个程序片段给试图添加了三个 UIImageView，分别显示原始大小的图片、无端帽拉伸之后的图片、和指定了正确的端帽宽度（用 stretchableImage）后拉伸的图片。

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.

  UIImage* image = [UIImage imageNamed:@"circle.png"];
  UIImage* stretchableImage = [image stretchableImageWithLeftCapWidth:10
                                                         topCapHeight:10];

  UIImageView* imageView1 = [[[UIImageView alloc] initWithImage:image]
                             autorelease];
  imageView1.center = CGPointMake(20, 20);
  [self.view addSubview:imageView1];

  UIImageView* imageView2 = [[[UIImageView alloc] initWithImage:image]
                             autorelease];
  imageView2.frame = CGRectMake(0, 0, 260, 200);
  imageView2.center = CGPointMake(160, 120);
  [self.view addSubview:imageView2];

  UIImageView* imageView3 = [[[UIImageView alloc]
                              initWithImage:stretchableImage]
                             autorelease];
  imageView3.frame = CGRectMake(0, 0, 260, 200);
  imageView3.center = CGPointMake(160, 340);
  [self.view addSubview:imageView3];
}

运行后效果如下图示：

UIImage 拉伸示意（左上角：原始图片；上：直接拉伸；下：按照端帽拉伸）

iOS 自定义范围滑动条控件

2012-02-03T21:19:00+08:00

前些日子写 app 的时候遇到一个需求，希望有一个类似于 UISlider 的东西，但能够选取一个范围，也就是所谓的 Range Slider。在网上也能找到很多相关的代码，不过本着学习的态度，还是自己琢磨了一下。

就当是为以后写复杂控件做的练习吧。

以下内容适用于 iOS 2.0+。

需求决定一切，在介绍我的这个 Range Slider 之前，先把我的需求（或者说我这个 Range Slider 的功能）介绍一下。它最多只算是个 toy，还有很多需要完善的地方。不过聊胜于无，以后继续努力呗。

这是一个水平方向的（浮点）数值范围选择器：

可以为它设置数值的最小值（minimumValue）和最大值（maximumValue），分别对应于滑动条最左端和最右端的数值。
可以设置范围的最小值（minimumSpan）和最大值（maximumSpan），因为我可能会要求选择的数值区间长度不太短或不太长。
可以获取或设置当前选择的数值范围（smallValue 和 largeValue），对应于界面上左右两个滑块的位置。
左右两个滑块都可以相互独立地左右滑动；一个滑块滑动时，另一个滑块会根据需要自动调整。比如当向左滑动左边的滑块时，如果选取的范围已经达到范围最大值（maximumSpan），右边的滑块就会跟着向左滑动。反之亦然。
两个滑块中间的条块也是可以滑动的，移动它的时候，两个滑块会一起左右移动（不改变选取范围的长度）。
当滑块或者滑条移动时，此控件的 UIControlEventValueChanged 事件会被触发。
可以用程序修改当前的选择范围，UI 会跟着调整，但不会触发上述事件，以免在某些情况下陷入死循环。
以左滑块为例，当它滑动到最左边后，如果手指继续做向左滑动的动作，当前选择的范围不会变化，但会通过另一个量（offsetTrend）来表达这种趋势。在某些情况下，应用程序可能会需要得到这样的信息，以便当用户在 slider 边缘继续往外滑动时，进行一些特殊的处理。右滑块和滑条都有同样的功能。
可以为这个控件设置委托（delegate），当滑块或者滑条将要开始滑动、或者滑动结束的时候，委托的对象都会收到相应的消息。当然，会有一个只读的量（isDragging）用来查询是否有滑块或者滑条在滑动中。
slider 的背景条、滑块、滑条的图案都可以被替换。

我的这个 Range Slider 暂不支持的功能包括但不限于：

不支持纵向的滑动模式（或许可以直接利用旋转整个控件达到此目的）。
没有为自定义 UI 样式提供足够的接口。虽然背景和滑块的图片都能替换，但并不支持为每一个对象实例单独替换图片。比起 SDK 中的 UISlider，这方面的功能是相当薄弱的。

说了这么多，来看看它的样子吧。外表很简单，我用的背景、滑块和滑条图片都跟 UISlider 是一样的：

我的 Range Slider

实现起来蛮简单的，因为 SDK 已经提供了足够的支持。我的这个类就叫做 RangeSlider，继承自 UIControl 类。另外我还定义了它的委托类，叫做 RangeSliderDelegate。二者的接口如下：

RangeSlider

#import <UIKit/UIKit.h>

@protocol RangeSliderDelegate;

@interface RangeSlider : UIControl {
@private
    id<RangeSliderDelegate> delegate_;

    float minimumValue_;
    float maximumValue_;
    float minimumSpan_;
    float maximumSpan_;
    float smallValue_;
    float largeValue_;
    float offsetTrend_;
    int insetWidthLeft_;
    int rangeWidth_;

    UIImageView* selectionView_;
    UIImageView* smallHandle_;
    UIImageView* largeHandle_;

    BOOL isTrackingSmallHandle_;
    BOOL isTrackingLargeHandle_;
    BOOL isTrackingSelection_;
    BOOL isDragging_;
}

// The delegate object.
@property(nonatomic, assign) id<RangeSliderDelegate> delegate;

// The minimum value of the slider.
// The default value is 0.0.
@property(nonatomic, assign) float minimumValue;

// The maximum value of the slider.
// The default value is 1.0.
@property(nonatomic, assign) float maximumValue;

// The minimum span of the selected range.
// The default value is 0.1.
@property(nonatomic, assign) float minimumSpan;

// The maximum span of the selected range.
// The default value is 1.0.
@property(nonatomic, assign) float maximumSpan;

// The lower bound of the selected range.
@property(nonatomic, assign, setter=setSmallValue:) float smallValue;

// The higher bound of the selected range.
@property(nonatomic, assign, setter=setLargeValue:) float largeValue;

// A Boolean value that indicates whether the user has begun dragging.
@property(nonatomic, assign, readonly) BOOL isDragging;

// Initialization with frame, also specify the inset of left and right edge.
- (id)initWithFrame:(CGRect)frame insetLeft:(int)insetLeft insetRight:(int)insetRight;

// Move the current selection.
- (void)moveSelection:(float)offset;

// Gets offset trend, it will be reset to 0 after call finished.
- (float)getAndResetOffsetTrend;

// Converts slider value to x coor.
- (float)xForValue:(float)value;

// Converts x coor to slider value.
- (float)valueForX:(float)x;

@end

RangeSliderDelegate

@protocol RangeSliderDelegate<NSObject>
@optional

// Tells the delegate when the slider is about to start dragging.
// The delegate might not receive this message until dragging has occurred over a small distance.
- (void)rangeSliderWillBeginDragging:(RangeSlider*)rangeSlider;

// Tells the delegate when dragging ended in the range slider.
// This message is sent when the user's finger touches up after dragging.
- (void)rangeSliderDidEndDragging:(RangeSlider*)rangeSlider;

@end

接口中的大部分内容都在需求和功能介绍部分见过了。另外有两个方法，xForValue 和 valueForX，它们用来在 Range Slider 内部的坐标值和用户数值之间做转换，内容如下（这里的 insetWidth 是在 UI 上做的小伎俩，主要是为了保证滑块滑到最两端时也能有充足的空间来接受用户的点击）：

- (float)xForValue:(float)value {
    return insetWidthLeft_ + rangeWidth_ * (value - minimumValue_) / (maximumValue_ - minimumValue_);
}

- (float)valueForX:(float)x {
    return minimumValue_ + (x - insetWidthLeft_) * (maximumValue_ - minimumValue_) / rangeWidth_;
}

我就不贴完整的 .m 源文件了，只是逐个介绍一下重要的方法。

首先看初始化方法 initWithFrame，和更新显示的方法 updateSelectionView。这个没啥好说的，就是初始化成员变量，创建好相关的图片：

initWithFrame

- (id)initWithFrame:(CGRect)frame insetLeft:(int)insetLeft insetRight:(int)insetRight {
    self = [super initWithFrame:frame];
    if (self != nil) {
        // Set the initial state.
        minimumValue_ = 0.0f;
        maximumValue_ = 1.0f;
        minimumSpan_ = 0.1f;
        maximumSpan_ = 0.7f;
        smallValue_ = minimumValue_;
        largeValue_ = minimumValue_ + maximumSpan_;
        offsetTrend_ = 0.0f;
        insetWidthLeft_ = insetLeft;
        rangeWidth_ = frame.size.width - insetLeft - insetRight;

        isTrackingSmallHandle_ = NO;
        isTrackingLargeHandle_ = NO;
        isTrackingSelection_ = NO;
        isDragging_ = NO;

        float centerY = frame.size.height / 2.0f;

        // Background image.
        UIImageView* background = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-bg.png"]]
                                  autorelease];
        background.frame = CGRectMake(insetWidthLeft_, 0, rangeWidth_, background.frame.size.height);
        background.center = CGPointMake(background.center.x, centerY);
        [self addSubview:background];

        // Selection image.
        selectionView_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-select.png"]
                                            highlightedImage:[UIImage imageNamed:@"rangeslider-select-hover.png"]]
                          autorelease];
        selectionView_.center = CGPointMake(0, centerY);
        [self addSubview:selectionView_];

        // Left handle for small value selection.
        smallHandle_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-handle.png"]
                                          highlightedImage:[UIImage imageNamed:@"rangeslider-handle-hover.png"]]
                        autorelease];
        smallHandle_.center = CGPointMake(0, centerY);
        [self addSubview:smallHandle_];

        // Right handle for small value selection.
        largeHandle_ = [[[UIImageView alloc] initWithImage:[UIImage imageNamed:@"rangeslider-handle.png"]
                                          highlightedImage:[UIImage imageNamed:@"rangeslider-handle-hover.png"]]
                        autorelease];
        largeHandle_.center = CGPointMake(0, centerY);
        [self addSubview:largeHandle_];

        [self updateSelectionView];
    }

    return self;
}

updateSelectionView

- (void)updateSelectionView {
    smallHandle_.center = CGPointMake([self xForValue:smallValue_], smallHandle_.center.y);
    largeHandle_.center = CGPointMake([self xForValue:largeValue_], largeHandle_.center.y);
    selectionView_.frame = CGRectMake(smallHandle_.center.x,
                                      selectionView_.frame.origin.y,
                                      largeHandle_.center.x - smallHandle_.center.x,
                                      selectionView_.frame.size.height);
}

接下来看最重要的部分，就是处理触摸事件的方法。这些方法继承自基类 UIControl，分别是 beginTrackingWithTouch:withEvent:，continueTrackingWithTouch:withEvent:，和 endTrackingWithTouch:withEvent:。

beginTracking 和 endTracking 都很简单，在 beginTracking 的时候判断是哪个东西被拖动，让其进入高亮状态，修改成员变量记录当前的状态；在 endTracking 的时候取消高亮，恢复状态。

在 continueTracking 方法中，先获取手指移动的坐标偏移量，将其换算成数值的偏移量，然后就直接调用相应的设置函数修改已选择的数值区域。

注意 rangeSliderWillBeginDragging 和 rangeSliderDidEndDragging 这两个消息的回调时机。手指刚刚按在滑块上的时候，beginTracking 被调用，但这时并不表示用户开始已经开始拖动了，他可能只是按了一下，马上就抬起来。所以当手指按住滑块并有了第一次微小的位移时，continueTracking 被调用，这时就可以确定用户是在进行拖动操作。这时候才发送 rangeSliderWillBeginDragging 消息。最后当手指离开滑块时，拖动操作结束，发送 rangeSliderDidEndDragging 消息。

beginTrackingWithTouch

- (BOOL)beginTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {
    CGPoint touchPoint = [touch locationInView:self];
    if (CGRectContainsPoint(largeHandle_.frame, touchPoint)) {
        largeHandle_.highlighted = YES;
        isTrackingLargeHandle_ = YES;
    }
    else if (CGRectContainsPoint(smallHandle_.frame, touchPoint)) {
        smallHandle_.highlighted = YES;
        isTrackingSmallHandle_ = YES;
    }
    else if (CGRectContainsPoint(selectionView_.frame, touchPoint)) {
        selectionView_.highlighted = YES;
        isTrackingSelection_ = YES;
    }
    else {
        return NO;
    }

    isDragging_ = NO;
    return YES;
}

continueTrackingWithTouch

- (BOOL)continueTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {
    if (!isTrackingSmallHandle_ && !isTrackingLargeHandle_ && !isTrackingSelection_) {
        return NO;
    }

    if (!isDragging_) {
        isDragging_ = YES;
        if ([self.delegate respondsToSelector:@selector(rangeSliderWillBeginDragging:)]) {
            [self.delegate rangeSliderWillBeginDragging:self];
        }
    }

    float prev = [self valueForX:[touch previousLocationInView:self].x];
    float curr = [self valueForX:[touch locationInView:self].x];
    float offset = curr - prev;

    if (isTrackingSmallHandle_) {
        self.smallValue = smallValue_ + offset;
    }
    else if (isTrackingLargeHandle_) {
        self.largeValue = largeValue_ + offset;
    }
    else if (isTrackingSelection_) {
        [self moveSelection:offset];
    }

    [self sendActionsForControlEvents:UIControlEventValueChanged];
    return YES;
}

endTrackingWithTouch

- (void)endTrackingWithTouch:(UITouch*)touch withEvent:(UIEvent*)event {
    isTrackingSmallHandle_ = NO;
    isTrackingLargeHandle_ = NO;
    isTrackingSelection_ = NO;

    selectionView_.highlighted = NO;
    smallHandle_.highlighted = NO;
    largeHandle_.highlighted = NO;

    if (isDragging_) {
        isDragging_ = NO;
        if ([self.delegate respondsToSelector:@selector(rangeSliderDidEndDragging:)]) {
            [self.delegate rangeSliderDidEndDragging:self];
        }
    }
}

最后就是修改 smallValue、largeValue 和整个选取范围的方法，这些方法会在滑动过程中由上面的 continueTrackingWithTouch:withEvent: 调用，也可以由其他程序直接调用。

不但要保证 smallValue 和 largeValue 都在最小值和最大值范围之内，还要根据最小范围和最大范围的限制来进行适当的调整。

setSmallValue

- (void)setSmallValue:(float)value {
    smallValue_ = value;

    smallValue_ = MIN(MAX(smallValue_, minimumValue_), maximumValue_ - minimumSpan_);
    if (smallValue_ < largeValue_ - maximumSpan_) {
        largeValue_ = smallValue_ + maximumSpan_;
    }
    else if (smallValue_ > largeValue_ - minimumSpan_) {
        largeValue_ = smallValue_ + minimumSpan_;
    }

    offsetTrend_ = value - smallValue_;

    [self updateSelectionView];
}

setLargeValue

- (void)setLargeValue:(float)value {
    largeValue_ = value;

    largeValue_ = MAX(MIN(largeValue_, maximumValue_), minimumValue_ + minimumSpan_);
    if (largeValue_ < smallValue_ + minimumSpan_) {
        smallValue_ = largeValue_ - minimumSpan_;
    }
    if (largeValue_ > smallValue_ + maximumSpan_) {
        smallValue_ = largeValue_ - maximumSpan_;
    }

    offsetTrend_ = value - largeValue_;

    [self updateSelectionView];
}

moveSelection

- (void)moveSelection:(float)offset {
    float span = largeValue_ - smallValue_;
    float prevSmallValue = smallValue_;
    smallValue_ += offset;
    largeValue_ += offset;
    if (smallValue_ < minimumValue_) {
        smallValue_ = minimumValue_;
        largeValue_ = smallValue_ + span;
    }
    else if (largeValue_ > maximumValue_) {
        largeValue_ = maximumValue_;
        smallValue_ = largeValue_ - span;
    }

    offsetTrend_ = prevSmallValue + offset - smallValue_;

    [self updateSelectionView];
}

好了，基本上就这么些代码，还是很简单的。不放完整的程序文件了，只要了解了基本的处理方法，就可根据自己的需求去实现了。

iOS 在 UIAlertView 中显示进度条

2011-12-09T18:27:00+08:00

今天这个问题是，在一个 iPhone 程序中，我要在后台做大量的数据处理，希望在界面上显示一个进度条（Progress Bar）使得用户了解处理进度。这个进度条应该是在一个模态的窗口中，使界面上其他控件无法被操作。怎么用最简单的方法来实现这个功能？UIAlertView 是一个现成的模态窗口，如果能把进度条嵌入到它里面就好了。

以下内容适用于 iOS 2.0+。

我们知道，如果要显示一个 alert 窗口（比如用来显示错误或警告信息、询问用户是否确认某操作等等），只要简单地创建一个 UIAlertView 对象，再调用其 show 方法即可。示意代码如下：

UIAlertView* alertView = [[[UIAlertView alloc] initWithTitle:@"Title"
                                                     message:@"Message"
                                                    delegate:nil
                                           cancelButtonTitle:@"OK"
                                           otherButtonTitles:nil]
                          autorelease];
[alertView show];

如果要添加一个进度条，只要先创建并设置好一个 UIProgressView 的实例，再利用 addSubbiew 方法添加到 alertView 中即可。

在实际应用中，我可能需要在类中保存进度条的对象实例，以便更新其状态，因此先在自己的 ViewController 类中添加成员变量：

//  MySampleViewController.h
#import <UIKit/UIKit.h>

@interface MySampleViewController : UIViewController {
@private
    UIProgressView* progressView_;
}

@end

接下来写一个叫做 showProgressAlert 的方法来创建并显示带有进度条的 alert 窗口，其中高亮的部分就是把进度条添加到 alertView 中：

- (void)showProgressAlert:(NSString*)title withMessage:(NSString*)message {
    UIAlertView* alertView = [[[UIAlertView alloc] initWithTitle:title
                                                         message:message
                                                        delegate:nil
                                               cancelButtonTitle:nil
                                               otherButtonTitles:nil]
                              autorelease];

    progressView_ = [[UIProgressView alloc] initWithProgressViewStyle:UIProgressViewStyleBar];
    progressView_.frame = CGRectMake(30, 80, 225, 30);
    [alertView addSubview:progressView_];

    [alertView show];
}

为了让数据处理的子进程能够方便地修改进度条的值，再添加一个简单的方法：

1
2
3

- (void)updateProgress:(NSNumber*)progress {
    progressView_.progress = [progress floatValue];
}

另外，数据处理完毕后，我们还需要让进度条以及 alertView 消失，由于之前并没有保存 alertView 的实例，可以通过进度条的 superview 访问之：

- (void)dismissProgressAlert {
    if (progressView_ == nil) {
        return;
    }

    if ([progressView_.superview isKindOfClass:[UIAlertView class]]) {
        UIAlertView* alertView = (UIAlertView*)progressView_.superview;
        [alertView dismissWithClickedButtonIndex:0 animated:NO];
    }

    [progressView_ release];
    progressView_ = nil;
}

假设处理数据的方法叫 processData，当然它会在一个单独的线程中运行，下面的片段示意了如何更新进度条状态，以及最后如何让它消失。

- (void)processData:(int)total {
    for (int i = 0; i < total; ++i) {
        // Update UI to show progess.
        float progress = (float)i / total;
        NSNumber* progressNumber = [NSNumber numberWithFloat:progress];
        [self performSelectorOnMainThread:@selector(updateProgress:)
                               withObject:progressNumber
                            waitUntilDone:NO];

        // Process.
        // do it.
    }

    // Finished.
    [self performSelectorOnMainThread:@selector(dismissProgressAlert)
                           withObject:nil
                        waitUntilDone:YES];
    // Other finalizations.
}

在实际使用中，带进度条的 alert view 大概长得是这样的：

带进度条的 alert 窗口

参考：

UIProgressView in UIAlertView?

iOS 隐藏系统状态栏

2011-11-30T14:45:00+08:00

最近在写 iPhone 上的程序，第一次在 Mac 下进行开发，也是第一次写手机上的程序，虽然之前看了少许相关的书籍，但在开发的过程中还是遇到了很多的问题。在这个系列中记录一些遇到的实际的问题，方便淡忘了之后再次查阅。

今天的问题是怎么在 App 中隐藏系统状态栏（Status Bar）。

以下内容适用于 iOS 3.2+。

一、始终隐藏状态栏

如果在 App 中需要状态栏一直是隐藏着的，可以在 <YOUR_APP>AppDelegate 的 application:didFinishLaunchingWithOptions: 函数中进行设置，比如下面这段示意代码可以让状态栏以淡出的方式隐藏起来：

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    [application setStatusBarHidden:NO withAnimation:UIStatusBarAnimationFade];

    // Add the view controller's view to the window and display.
    [self.window addSubview:viewController.view];
    [self.window makeKeyAndVisible];

    return YES;
}

相关的方法或属性是 UIApplication 的：

setStatusBarHidden:withAnimation:（iOS 3.2+）
statusBarHidden（iOS 2.0+）

另外还有一个方法 setStatusBarHidden:animated:，已经不推荐使用了（deprecated in iOS 3.2）。

二、App 启动时就隐藏状态栏

用了上面的方法之后，App 在运行过程中，状态栏确实被隐藏起来了，但是我发现在 App 启动的那个瞬间，还是可以看到状态栏的，然后一闪即过。虽然时间很短暂，看着还是很不舒服。为了让状态栏从启动的时候就隐藏起来，可以修改 <YOUR_APP>-Info.plist。如果在 Xcode 中修改，在根结点 Infomation Property List 下面新加一项 “Status bar is initially hidden”（不用手动输入，可以直接在下拉菜单中选取）。这是个 BOOL 类型的键值，将 Value 栏中的复选框勾选上即可。

在 Info.plist 中设置状态栏为隐藏

也可以以文本方式修改，在根节点中添加 UIStatusBarHidden 键值，值设为 true 即可：

<key>UIStatusBarHidden</key>
<true/>

三、在运行过程中隐藏或显示状态栏

与第一段中的方法一样，只是可以在任何地方调用。只要利用 UIApplication 类的静态方法 sharedApplication 拿到 application 实例即可。

可以继承的 C++ Singleton 基类

2011-08-12T23:20:00+08:00

单例模式（Singleton Pattern）是设计模式中的一种，它用来保证系统中最多只能存在一个它的实例，其做法是由类自身来创建和持有它的对象实例，把对实例的创建权和管理权都控制在自己手中，以便控制实例数目。

关于如何在 C++ 中实现单例模式的讨论已经太多了，我只是简单介绍一下可以继承的单例类。

首先介绍一下通常所见的单例类的写法，不妨设这个类叫做 Singleton。

Singleton.h：

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

#include <memory>

class Singleton
{
public:
    static Singleton& GetInstance();

private:
    Singleton();
    ~Singleton();

    // Use auto_ptr to make sure that the allocated memory for instance
    // will be released when program exits (after main() ends).
    static std::auto_ptr<Singleton> s_instance;
    friend class std::auto_ptr<Singleton>;

    Singleton(const Singleton&);
    Singleton& operator =(const Singleton&);
};

#endif

Singleton.cpp：

#include "Singleton.h"
#include <iostream>
#include <boost/thread.hpp>

using namespace std;
using namespace boost;

auto_ptr<Singleton> Singleton::s_instance;

Singleton::Singleton()
{
    cout << "Construct Singleton" << endl;
}

Singleton::~Singleton()
{
    cout << "Destruct Singleton" << endl;
}

Singleton& Singleton::GetInstance()
{
    static mutex s_mutex;
    if (s_instance.get() == NULL)
    {
        mutex::scoped_lock lock(s_mutex);
        if (s_instance.get() == NULL)
        {
            s_instance.reset(new Singleton());
        }
        // 'lock' will be destructed now. 's_mutex' will be unlocked.
    }
    return *s_instance;
}

这个类写的也不完美啦，比如双重判定也会有失效的时候，不过凑合用吧，哈哈。不过话说 boost 库里也有 singleton，我为什么要自己写个呢，无奈地飘过。

废话不多说了，上面的单例类基本上解决了多线程安全问题、实例内存自动释放问题，算是一段可以使用的程序。不过如果系统中有大量单例类（这时候也得好好考虑一下 design 有没有问题），每个都要这么写一番岂不是很麻烦？要是可以写一个单例基类，以后再创造单例类的时候直接继承一下多方便啊。不过很明显的问题就在那个 static 对象指针，这个用来保存唯一实例的静态变量如果定义在基类里面，那所有的子类都只能用这同一个变量来保存它们各自的实例了，社会主义国家总得让每个子类都过上温饱生活吧！

以前的时候我还真不知道该怎么解决这个问题，但 05 年用了 WTL（Windows Template Library）之后，我才意识到模板类可以帮助我（话说我真的是自己想到的，虽然现在搜一下能搜到一大堆）。这里要用的还不是普通的模板类，而是像 ATL、WTL 里面那样把要定义的类自身放入模板参数中，形如 class MyClass : public Base<MyClass> {};。这样做有很多优点啦，最显著的比如不需要虚表（节省内存哦）、多态函数的调用在编译时就确定了（既加快了运行速度，也有利于编译器对代码进行优化）。

不妨把这个单例基类叫做 ISingleton 吧，看起来好像是个 interface 呢。代码如下：

#ifndef _ISingleton_H_
#define _ISingleton_H_

#include <memory>
#include <boost/thread.hpp>

template <typename T>
class ISingleton
{
public:
    static T& GetInstance()
    {
        static boost::mutex s_mutex;
        if (s_instance.get() == NULL)
        {
            boost::mutex::scoped_lock lock(s_mutex);
            if (s_instance.get() == NULL)
            {
                s_instance.reset(new T());
            }
            // 'lock' will be destructed now. 's_mutex' will be unlocked.
        }
        return *s_instance;
    }

protected:
    ISingleton() {}
    ~ISingleton() {}

    // Use auto_ptr to make sure that the allocated memory for instance
    // will be released when program exits (after main() ends).
    static std::auto_ptr<T> s_instance;

private:
    ISingleton(const Singleton&);
    ISingleton& operator =(const ISingleton&);
};

template <typename T>
std::auto_ptr<T> ISingleton<T>::s_instance;

#endif

要利用 ISingleton 创建一个自己的单例类，比如 MySingleton，可以使用如下的代码：

#include "Singleton.h"
#include "ISingleton.h"
#include <iostream>

using namespace std;

class MySingleton : public ISingleton<MySingleton>
{
public:
    // blah blah

private:
    MySingleton()
    {
        cout << "Construct MySingleton" << endl;
    }

    ~MySingleton()
    {
        cout << "Destruct MySingleton" << endl;
    }

    friend ISingleton<MySingleton>;
    friend class auto_ptr<MySingleton>;

    MySingleton(const MySingleton&);
    MySingleton& operator =(const MySingleton&);
};

最最重要的，千万不要忘了把 MySingleton 的构造和析构函数弄成 private 的，还要添加两个友元。有人说 ISingleton 和 MySingleton 的析构函数都要加 virtual，我倒是觉得没有必要呢，你说呢？另外要注意，MySingleton 不能被继承哦。

C++ 中的常量指针和指针常量

2011-08-04T23:39:00+08:00

太久不用 C++ 了，竟然连最基本的东西都记不清楚了。今天干活的时候突然想要用指针常量，但突然就忘了指针常量跟常量指针的区别。花了一点儿时间仔细回想了一下几年前上课时老师讲的，总算又回忆起来了，赶紧记录下来备忘。

这可能会被当作面试题，不过不是算法，故而不放在面试算法题系列中。

我觉得容易混淆的罪魁祸首在于中文的翻译问题，如果改叫“常量的指针”和“指针常量”可能会好些。先不管这些，看看英文的叫法：Pointer to Const 和 Const Pointer。

Pointer to Const，顾名思义就是一个指针，指向的数据不能被修改，C++ 语法是 int const* ptr。怎么记忆呢，非常简单，记住要从右往左解读即可。首先这是个变量（ptr）；然后发现它是个指针（*）；接下来看到它所指向的数据是不可修改的（const）；最后这个指针所指向的空间存放的是整数（int）。

Const Pointer，也是个指针，但这个指针的值不能被修改（不能再指向其他地方），C++ 语法是 int* const ptr。同样从右往左读，变量（ptr）；变量的值不能被修改（const）；是个指针（*）；这个指针所指向的空间存放的是整数（int）。

可见 const 修饰的是它右边紧邻的元素，如果右边是指针 *，就表明指针指向的是常量，不能被修改；如果右边是变量，就变明这个变量自身不能被修改。

下面这段 C++ 程序示意了两种指针的区别，其中被注释掉的两行（高亮显示）是因为会无法编译。

int a1 = 1;
int b1 = 2;
int c1 = 3;

int* pointer = &a1;
int const* pointerToConst = &b1;
int* const constPointer = &c1;

int a2 = 10;
int b2 = 20;
int c2 = 30;
pointer = &a2;
pointerToConst = &b2;
//constPointer = &c2;  // the pointer cannot be moved

*pointer += 100;
//*pointerToConst += 100;  // the pointed data cannot be changed
*constPointer += 100;

cout << "*pointer = " << *pointer << "\n"
     << "*pointerToConst = " << *pointerToConst << "\n"
     << "*constPointer = " << *constPointer << endl;

显然程序的输出应该是：

1
2
3

*pointer = 110
*pointerToConst = 20
*constPointer = 103

对英文名称理解清楚了，记不记中文名字也就无所谓了吧。我的记忆方法就是“Pointer to Const”翻译为“常量的指针”，简称“常量指针”；“Const Pointer”翻译为“指针常量”。

最后简单总结一下跟 const 相关的变量的写法：

int a = 0;
int b = 1;

// An int that cannot be changed.
const int constNumber_1 = a;
int const constNumber_2 = a;
//constNumber_1 = 10;

// A pointer that can be repointed to an int that cannot be changed.
const int* pointerToConst_1 = &a;
int const* pointerToConst_2 = &a;
pointerToConst_1 = &b;
//*pointerToConst_1 = 10;

// A pointer that cannot be moved to an integer that may be changed.
int* const constPointer = &a;
//constPointer = &b;
*constPointer = 10;

// A pointer that cannot be moved to an integer that cannot be changed.
const int* const constPointerToConst_1 = &a;
int const* const constPointerToConst_2 = &a;
//constPointerToConst_1 = &b;
//*constPointerToConst_1 = 10;

// Error, const applied to int twice.
// (warning C4114: same type qualifier used more than once).
const int const* pointerToTwiceConst = &a;
pointerToTwiceConst = &b;
//*pointerToTwiceConst = 10;

// A pointer that may be repointed. It points to a pointer that cannot be moved to
// an int that may be modified.
int* pa = &a;
int* const* pointerToConstPointer = &pa;
int* pb = &b;
pointerToConstPointer = &pb;
//*pointerToConstPointer = pb;
**pointerToConstPointer = 10;