Zair

Zair 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

Zair 发布了文章 · 2015-02-11

【Clojure】Sublime Text 下的开发环境配置

小记一下Clojure开发环境安装过程。

由于是Sublime Text用户,首先按照官方推荐(Getting Started With Sublime Text 2)配置了SublimeREPL插件,并安装了Leiningen。这里需要指出在ST里调出Clojure REPL的快捷键应该是Ctrl+F12,C,S,没错,四次按键。

然而不幸遇到了REPL无响应的问题,放弃折腾了。毕竟安了Leiningen,在cmd里输入lein repl也能比较方便地调用REPL。

可我还是希望能直接在ST里运行代码,很巧地找到了一个分享,正是我喜欢的Ctrl+B方式。之前我在ST中自建过Perl的Build System,而且按照分享操作遇到必须加'.bat'后缀的情况,所以改进如下,这样就可以让ST自动选择Build System啦:

{
    "cmd": "clj.bat $file",
    "selector": "source.clojure"
}

/*当然写成下面的形式也是可以的,注意路径*/

{
    "cmd": "java -cp C:/clojure-1.6.0/clojure-1.6.0.jar clojure.main $file",
    "selector": "source.clojure"
}
查看原文

赞 1 收藏 0 评论 1

Zair 赞了回答 · 2015-02-07

解决【Perl】字符串匹配:如何正确匹配出’aaaa'中的3个‘aa'模式?

perl#!/usr/bin/perl
$a = 'aaaa';
$i ++ while $a =~ /a(?=a)/g;
print $i;

正则本质是状态机一个个consume字符扭转状态,捕获成功第一个aa以后相当于前两个字符都被consume掉从第三个a开始匹配了,所以原来的结果是2,这里用零宽断言让正则去look ahead匹配模式里第二个a而不将其consume掉,从而得到3

编译原理学得不好,解释得有点乱……


图形的力量,感觉比字清楚多了

图片描述

关注 3 回答 2

Zair 回答了问题 · 2015-02-06

解决请教一个正则表达式

Perl

$a = 'sasa<app>sasa<server>sasa<client>ddsdds';
@ary = $a =~ /<(.+?)>/g;
print "@ary";

关注 1 回答 5

Zair 提出了问题 · 2015-02-06

解决【Perl】字符串匹配:如何正确匹配出’aaaa'中的3个‘aa'模式?

一段Perl的代码,输出结果为2。然而显然在字符串'aaaa'中含有3个'aa'模式。请问如何做到3次匹配?

#!/usr/bin/perl
$a = 'aaaa';
$i ++ while $a =~ /aa/g;
print $i;

关注 3 回答 2

Zair 赞了文章 · 2015-02-04

vim编辑器技巧备忘(初级-中级)

“学习vim并且其会成为你最后一个使用的文本编辑器”
学习建议:

  • 丢弃鼠标和小键盘
  • 具有搭配使用各种按键的意识

首先来一张 mindmap :

vim-learn-card

初级

编辑模式(Insert Mode)

编辑模式包括以下动作:

  • insert:i在光标所在字符前插入,I在当前行首第一个非空格字符前插入
  • append:a在光标所在字符后插入,A在行末尾开始插入
  • open:o在下一行插入新行,O在光标所在行的上一行插入新行
  • replace:r将光标处字符替换成r紧接的字符;R一直替换字符串,知道ESC键退出,同windows下的Insert键
  • Ctrl+p:自动提示
  • [ESC]:回到普通模式

vim-mode

普通模式(Normal Mode)

  • h, j, k, l,分别对应 左← 下↓ 上↑ 右→
  • :q, :q!, :wq 退出 不保存强行退出 保存退出

  • 移动光标到当前行首/非空格,同^,:0

  • $ 移动光标到当前行尾,同:$
  • G 移动光标到文档最后一行首
  • 30G 转到第30行,同 :30
  • 9- 光标向上移动9行,同9k
  • 9+ 光饼向下移动9行,同9[space],9j

  • gg 转到文档第一行(1G)

  • H 移动到屏幕的第一列
  • M 移动到屏幕的中间列
  • L 移动到屏幕的最后列

  • w 移动到下一个单词的首字母,(标点符号认为是一个单词,W表示单词以空格分隔)

  • e 移动到下一个单词的末尾,(E认为单词以空格分隔)

  • b 移动到上一个单词的首字母,(B认为单词以空格分隔)

  • fx 移动到下一个字母是x的位置。Fx向上移动。
  • % 匹配括号移动,包括 (, {, [ ,你需要把光标先移到括号上

  • CTRL+b 向上(前)翻页

  • CTRL+f 向后翻页

  • d 删除开始。其实是放到寄存器中,p或P命令调用。c即change,删完进入编辑模式

  • d$ 删除光标到行尾的所有文字,同D。C指令进入编辑模式
  • dw 删除当前字符到单词尾的所有字符。cw删除光标后的单词并进入插入模式,等同替换
  • dd 删除当前一行
  • 2dd 删除当前两行
  • x 剪切光标处字符,可以p粘贴出来

  • y 复制开始。yank起来,p或P命令调用

  • yy p 复制当前行并粘贴到下一行
  • 5yy p 复制当前行以下5行,在合适的地方粘贴
  • yw p 复制一个单词并粘贴。
  • yi{ 复制光标所在{}中的内容。很容易知道ci{ 和 di " 的意思。

  • u 撤销

  • CTRL+r 重做
  • . 点号重复做上一个命令
  • ``.` 移动光标到上一次的修改点

  • Ctrl+g 查看我当前位置

命令模式

  • /word 向下查找word,n定位到下一个。?word 向上开始查找,同/word配合N。*直接查找光标所在处单词
  • :%s/word1/word2/g 替换所有word1为word2(^$ [])
  • :set noic 区分大小写 (即set no igorecase,set ic不区分大小写)

  • :set nu 显示行号。:set nonu相反,不显示行号

  • :set paste 设置为粘贴模式,解决Ctrl+Insert粘贴时缩进错乱问题。:set nopaste设置回默认
  • :se ff=unix 设置文本文件的格式为unix,去掉windows系统文件中的^M。

  • :!ls 执行bash下的命令ls,回车后继续回到vi。一般在一个不存在的目录中创建文件时用到

  • :set all 查看vim说有设置属性值
  • :map 查看绑定的快捷键
  • :marks 查看可用标记

熟练上面的命令,已经可以满足日常工作要求,要提高效率可以学习vim的高级用法,如分屏显示、分页、标签功能、代码折叠、键盘映射。

可视化模式

visual mode多用于用键盘灵活选择文本。vV键进入,可以实现同时编辑多行(如注释)

中级

高级组合命令

  • :sh 暂时离开vi,进入shell命令行
  • :!ls !表示要执行一个shell命令
  • q: 调出历史命令窗口
  • cc 替换一行,清空一行
  • cw 替换一个单词,进入插入模式
  • ea 在当前单词最后插入

  • vw visual模式选择一个单词

  • VU 全选一行,转换成大写
  • :5,12 co 13 将5至12行复制到第13行下

  • gg=G 自动缩排文件
    % : 匹配括号移动,包括 (, {, [. ,你需要把光标先移到括号上
    *#:匹配光标当前所在的单词,移动光标到下一个(或上一个)匹配单词(*是下一个,#是上一个)

当光标在( ), [ ],< >, { }, " ", '' 内时,可以用ci, di, 或yi,加上(, [, <,{, ", '。这样可以改写/删除/复制( )内,[ ]内,< >内,{ }内," "内,' '内的内容。

多行注释(块操作)

  1. 首先按esc进入命令行模式下,按下Ctrl + v,进入列(也叫区块)模式;
  2. 在行首使用上下键kj选择需要注释的多行;
  3. 按下键盘(大写)I键,进入插入模式;
  4. 然后输入注释符(“//”、“#”等);
  5. 最后按下esc

删除多行开头的一个字符与此类似,删除多个字符也只要左右键,然后使用d。

另外一种多行注释的方式就是替换:

  • :5,9s/^/#/g 添加注释#
  • :5,9s/^#//g 删除注释#
  • :5,9s#^#//#g 添加注释//,同:5,9s/^/\/\/#/g
  • :5,9s#^//##g 删除注释//

多行缩进
[ESC], Ctrl+v 选择行 <或>左右缩进,=自动缩进(gg=G的局部功能)

多行行末尾加上 >> ${log}:Ctrl+v /^echo
>>相当于tab键,一个缩进

多行删除

  1. 首先在命令模式下,输入set nu显示行号;
  2. 通过行号确定你要删除的行;
  3. 命令输入:32,65d,回车键,32-65行就被删除了

自动补全
在Insert模式下,你可以输入一个词的开头,然后按 <C-p>或是<C-n>,自动补齐功能就出现了

分屏(split)

分割窗口(同时编辑多个文件)

  • vi -o file1 file2 水平分屏,也可以在先打开file1后,使用:sp file2
  • vi -O file1 file2 垂直分屏,也可以在先打开file1后,使用:vsp file2
  • Ctrl+w w 光标切换到另一个屏
  • k 关闭当前窗口,如果有改动则提示要先保存。:wqa!保存退出所有文件
  • Ctrl+w v 左右分割当前打开的文件。Ctrl+w s上下分割显示
  • Ctrl+w H 左移该屏(大写,L右移,K上移—改变vertical为horizontal)
  • :set scb 分屏同步滚动

另外一种不分屏,同时编辑多个文件的方法

vi file1 file2

  • :ls 展示全部打开的文档。其中 % 代表正在打开的文件(buffer),# 代表上一个编辑过的文件,a 代表当前激活的buffer空间,+ 代表有修改过的内容但还未保存
  • :buffer 2 转到打开的第二个文件。或简写为 :b2
  • :bn 转到下一个文件。没有保存不能离开这个文件。:bp 上一个文件
  • :b# 转到上一个编辑过的文件,同 :e #。类似于多屏中Ctrl+w w
  • :e file3 编辑一个新的文件
  • Ctrl+g 显示当前文件名和行号,同 :f

折叠(fold)

主要应用在复杂脚本的场合,特别是函数比较多,逻辑结构比较复杂的代码。(:help folding
有6种方式来折叠代码

  1. manual //手工定义折叠
  2. indent //用缩进表示折叠
  3. expr  //用表达式来定义折叠
  4. syntax //用语法高亮来定义折叠
  5. diff //对没有更改的文本进行折叠
  6. marker //用标志折叠

indent
:set foldmethod=indent 设置缩进折叠,fdm为简写。只对当前会话有效,要使每次打开vim时折叠都生效,则在.vimrc文件中添加设置,如添加:set fdm=indent

  • zc 折叠与当前缩进相同的行
  • zo 打开折叠
  • zj 移到下一个折叠处
  • zk 移到上一个折叠处
  • zm 折叠所有可折叠标记
  • zr 展开所有折叠
  • [z 到当前打开折叠的开始
  • ]z 到当前打开折叠的结束

marker
注意与后文的mark不是同一东西,:set fdm=marker

  • zf 创建marker,默认 #{{{,#}}}
  • Ctrl+v zf 进入可视化模式,选择需要折叠的行,zc执行折叠。会自动加入 #{{{ code block #}}}
  • zf9j 创建从当前行起至以下9行的折叠标记,zc进行折叠。同9zf。类似有zf30G,从当前行折叠刀第30行
  • zf% 创建匹配的 {}, [], (), <> 的fold。不用执行zc
  • zd 删除当前行上存在的折叠标记。仅当 'foldmethod' 设为 "manual" 或 "marker" 时有效

标记

标记(mark)是vim提供的精确定位技术,只要你知道标记的名字,就可以使用命令直接跳转到该标记所在的位置。vim中的标记都有一个名字,这个名字用单一的字符表示。大写和小写字母(A-Za-z)都可以做为标记的名字,这些标志的位置可以由用户来设置;而数字标记0-9,以及一些标点符号标记,用户不能进行设置,由vim来自动设置。(:help mark-motions查看更多帮助)

  • ms 定义一个标记s
  • `s 跳转到标记s的地方
  • 's 跳转到调剂s所在行首
  • `. jump to position where last change occurred in current buffer
  • `` jump back (to position in current buffer where jumped from)
  • :delmarks aA。使用:delmarks!删除所有小写(a-z)的标记
  • :marks 查看所有标记

插件

待续

vimrc

.vimrc 是目前自己用的比较习惯的vim风格。

参考


原文链接地址:http://seanlook.com/2014/08/07/vim-tips/


查看原文

赞 10 收藏 88 评论 6

Zair 收藏了文章 · 2014-09-09

Python -- 让你的代码运行的更快的技巧

注:原文地址 Python: faster way

注:个人学习记录用。建议大家看原文,原文对比更加清晰,一目了然。

注:各位要使用这些技巧的话,请在自己的服务器上测试一遍,并且加大测试的数值,目前的用例都是 10 W 次,我们可以测试 100 W , 1000 W 次。。。。
注:如果测试的性能相差不多,请以可读性为主。

平台

运行测试的平台环境:

>>> import sys
>>> import platform
>>> platform.system()
'Linux'
>>> platform.release()
'3.11.0-19-generic'
>>> sys.version
'2.7.5+ (default, Feb 27 2014, 19:37:08) 
[GCC 4.8.1]'
>>> from timeit import timeit
>>> from dis import dis
>>> 

以下的代码主要是使用了 timeit 函数测试处理时间,以及使用 dis 函数显示详细的处理步骤(汇编的方式),能让你清楚的知道,慢在哪里?为什么慢?

测试用例 1

更快的方式:

def a():
    d = {}
    return d

>>> 
>>> timeit(a, number=1000000)
... 0.0905051231384
>>> 
>>> dis(a)
  5           0 BUILD_MAP                0
              3 STORE_FAST               0 (d)

  6           6 LOAD_FAST                0 (d)
              9 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    d = dict()
    return d

>>> 
>>> timeit(a, number=1000000)
... 0.206549167633
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (dict)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (d)

  6           9 LOAD_FAST                0 (d)
             12 RETURN_VALUE        

>>> 

测试用例 2

更快的方式:

def a():
    l = [0, 8, 6, 4, 2, 1, 3, 5, 7, 9]
    l.sort()
    return l

>>> 
>>> timeit(a, number=1000000)
... 0.53688287735
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 LOAD_CONST               2 (8)
              6 LOAD_CONST               3 (6)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (2)
             15 LOAD_CONST               6 (1)
             18 LOAD_CONST               7 (3)
             21 LOAD_CONST               8 (5)
             24 LOAD_CONST               9 (7)
             27 LOAD_CONST              10 (9)
             30 BUILD_LIST              10
             33 STORE_FAST               0 (l)

  6          36 LOAD_FAST                0 (l)
             39 LOAD_ATTR                0 (sort)
             42 CALL_FUNCTION            0
             45 POP_TOP             

  7          46 LOAD_FAST                0 (l)
             49 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    l = [0, 8, 6, 4, 2, 1, 3, 5, 7, 9]
    return sorted(l)

>>> 
>>> timeit(a, number=1000000)
... 0.781757831573
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 LOAD_CONST               2 (8)
              6 LOAD_CONST               3 (6)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (2)
             15 LOAD_CONST               6 (1)
             18 LOAD_CONST               7 (3)
             21 LOAD_CONST               8 (5)
             24 LOAD_CONST               9 (7)
             27 LOAD_CONST              10 (9)
             30 BUILD_LIST              10
             33 STORE_FAST               0 (l)

  6          36 LOAD_GLOBAL              0 (sorted)
             39 LOAD_FAST                0 (l)
             42 CALL_FUNCTION            1
             45 RETURN_VALUE        

>>> 

测试用例 3

更快的方式:

def a():
    a, b, c, d, e, f, g, h, i, j = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    return j, i, h, g, f, e, d, c, b, a

>>> 
>>> timeit(a, number=1000000)
... 0.216089963913
>>> 
>>> dis(a)
  5           0 LOAD_CONST              11 ((0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
              3 UNPACK_SEQUENCE         10
              6 STORE_FAST               0 (a)
              9 STORE_FAST               1 (b)
             12 STORE_FAST               2 (c)
             15 STORE_FAST               3 (d)
             18 STORE_FAST               4 (e)
             21 STORE_FAST               5 (f)
             24 STORE_FAST               6 (g)
             27 STORE_FAST               7 (h)
             30 STORE_FAST               8 (i)
             33 STORE_FAST               9 (j)

  6          36 LOAD_FAST                9 (j)
             39 LOAD_FAST                8 (i)
             42 LOAD_FAST                7 (h)
             45 LOAD_FAST                6 (g)
             48 LOAD_FAST                5 (f)
             51 LOAD_FAST                4 (e)
             54 LOAD_FAST                3 (d)
             57 LOAD_FAST                2 (c)
             60 LOAD_FAST                1 (b)
             63 LOAD_FAST                0 (a)
             66 BUILD_TUPLE             10
             69 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = 0
    b = 1
    c = 2
    d = 3
    e = 4
    f = 5
    g = 6
    h = 7
    i = 8
    j = 9
    return j, i, h, g, f, e, d, c, b, a

>>> 
>>> timeit(a, number=1000000)
... 0.249029874802
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (a)

  6           6 LOAD_CONST               2 (1)
              9 STORE_FAST               1 (b)

  7          12 LOAD_CONST               3 (2)
             15 STORE_FAST               2 (c)

  8          18 LOAD_CONST               4 (3)
             21 STORE_FAST               3 (d)

  9          24 LOAD_CONST               5 (4)
             27 STORE_FAST               4 (e)

 10          30 LOAD_CONST               6 (5)
             33 STORE_FAST               5 (f)

 11          36 LOAD_CONST               7 (6)
             39 STORE_FAST               6 (g)

 12          42 LOAD_CONST               8 (7)
             45 STORE_FAST               7 (h)

 13          48 LOAD_CONST               9 (8)
             51 STORE_FAST               8 (i)

 14          54 LOAD_CONST              10 (9)
             57 STORE_FAST               9 (j)

 15          60 LOAD_FAST                9 (j)
             63 LOAD_FAST                8 (i)
             66 LOAD_FAST                7 (h)
             69 LOAD_FAST                6 (g)
             72 LOAD_FAST                5 (f)
             75 LOAD_FAST                4 (e)
             78 LOAD_FAST                3 (d)
             81 LOAD_FAST                2 (c)
             84 LOAD_FAST                1 (b)
             87 LOAD_FAST                0 (a)
             90 BUILD_TUPLE             10
             93 RETURN_VALUE        

>>> 

测试用例 4

更快的方式:

def a():
    a, b, c, d, e, f = 2, 5, 52, 25, 225, 552
    if a < b and b < c and c < d and d < e and e < f:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.176034927368
>>> 
>>> dis(a)
  5           0 LOAD_CONST               7 ((2, 5, 52, 25, 225, 552))
              3 UNPACK_SEQUENCE          6
              6 STORE_FAST               0 (a)
              9 STORE_FAST               1 (b)
             12 STORE_FAST               2 (c)
             15 STORE_FAST               3 (d)
             18 STORE_FAST               4 (e)
             21 STORE_FAST               5 (f)

  6          24 LOAD_FAST                0 (a)
             27 LOAD_FAST                1 (b)
             30 COMPARE_OP               0 (<)
             33 POP_JUMP_IF_FALSE       88
             36 LOAD_FAST                1 (b)
             39 LOAD_FAST                2 (c)
             42 COMPARE_OP               0 (<)
             45 POP_JUMP_IF_FALSE       88
             48 LOAD_FAST                2 (c)
             51 LOAD_FAST                3 (d)
             54 COMPARE_OP               0 (<)
             57 POP_JUMP_IF_FALSE       88
             60 LOAD_FAST                3 (d)
             63 LOAD_FAST                4 (e)
             66 COMPARE_OP               0 (<)
             69 POP_JUMP_IF_FALSE       88
             72 LOAD_FAST                4 (e)
             75 LOAD_FAST                5 (f)
             78 COMPARE_OP               0 (<)
             81 POP_JUMP_IF_FALSE       88

  7          84 LOAD_GLOBAL              0 (True)
             87 RETURN_VALUE        

  8     >>   88 LOAD_GLOBAL              1 (False)
             91 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a, b, c, d, e, f = 2, 5, 52, 25, 225, 552
    if a < b < c < d < e < f:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.208202123642
>>> 
>>> dis(a)
  5           0 LOAD_CONST               7 ((2, 5, 52, 25, 225, 552))
              3 UNPACK_SEQUENCE          6
              6 STORE_FAST               0 (a)
              9 STORE_FAST               1 (b)
             12 STORE_FAST               2 (c)
             15 STORE_FAST               3 (d)
             18 STORE_FAST               4 (e)
             21 STORE_FAST               5 (f)

  6          24 LOAD_FAST                0 (a)
             27 LOAD_FAST                1 (b)
             30 DUP_TOP             
             31 ROT_THREE           
             32 COMPARE_OP               0 (<)
             35 JUMP_IF_FALSE_OR_POP    80
             38 LOAD_FAST                2 (c)
             41 DUP_TOP             
             42 ROT_THREE           
             43 COMPARE_OP               0 (<)
             46 JUMP_IF_FALSE_OR_POP    80
             49 LOAD_FAST                3 (d)
             52 DUP_TOP             
             53 ROT_THREE           
             54 COMPARE_OP               0 (<)
             57 JUMP_IF_FALSE_OR_POP    80
             60 LOAD_FAST                4 (e)
             63 DUP_TOP             
             64 ROT_THREE           
             65 COMPARE_OP               0 (<)
             68 JUMP_IF_FALSE_OR_POP    80
             71 LOAD_FAST                5 (f)
             74 COMPARE_OP               0 (<)
             77 JUMP_FORWARD             2 (to 82)
        >>   80 ROT_TWO             
             81 POP_TOP             
        >>   82 POP_JUMP_IF_FALSE       89

  7          85 LOAD_GLOBAL              0 (True)
             88 RETURN_VALUE        

  8     >>   89 LOAD_GLOBAL              1 (False)
             92 RETURN_VALUE        

>>> 

测试用例 5

更快的方式:

def a():
    a = True
    if a:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.109908103943
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (True)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 POP_JUMP_IF_FALSE       16

  7          12 LOAD_GLOBAL              0 (True)
             15 RETURN_VALUE        

  8     >>   16 LOAD_GLOBAL              1 (False)
             19 RETURN_VALUE        

>>> 

更慢方式:

def a():
    a = True
    if a is True:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.141321897507
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (True)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_GLOBAL              0 (True)
             12 COMPARE_OP               8 (is)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    a = True
    if a == True:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.149966001511
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (True)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_GLOBAL              0 (True)
             12 COMPARE_OP               2 (==)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

测试用例 6

更快的方式:

def a():
    a = 1
    if not a is 2:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.0980911254883
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               2 (2)
             12 COMPARE_OP               9 (is not)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = 1
    if a is not 2:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.10059595108
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               2 (2)
             12 COMPARE_OP               9 (is not)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    a = 1
    if a != 2:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.102056026459
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               2 (2)
             12 COMPARE_OP               3 (!=)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

测试用例 7

更快的方式:

def a():
    a = []
    if a:
        return False
    return True

>>> 
>>> timeit(a, number=1000000)
... 0.111177921295
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 POP_JUMP_IF_FALSE       16

  7          12 LOAD_GLOBAL              0 (False)
             15 RETURN_VALUE        

  8     >>   16 LOAD_GLOBAL              1 (True)
             19 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = []
    if not a:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.113872051239
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 POP_JUMP_IF_TRUE        16

  7          12 LOAD_GLOBAL              0 (True)
             15 RETURN_VALUE        

  8     >>   16 LOAD_GLOBAL              1 (False)
             19 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    a = []
    if len(a) <= 0:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.13893699646
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (a)

  6           6 LOAD_GLOBAL              0 (len)
              9 LOAD_FAST                0 (a)
             12 CALL_FUNCTION            1
             15 LOAD_CONST               1 (0)
             18 COMPARE_OP               1 (<=)
             21 POP_JUMP_IF_FALSE       28

  7          24 LOAD_GLOBAL              1 (True)
             27 RETURN_VALUE        

  8     >>   28 LOAD_GLOBAL              2 (False)
             31 RETURN_VALUE        

>>> 

超级慢的方式:

def a():
    a = []
    if a == []:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.16094994545
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 BUILD_LIST               0
             12 COMPARE_OP               2 (==)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

测试用例 8

更快的方式:

def a():
    a = object()
    if not a:
        return False
    return True

>>> 
>>> timeit(a, number=1000000)
... 0.150635004044
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (object)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (a)

  6           9 LOAD_FAST                0 (a)
             12 POP_JUMP_IF_TRUE        19

  7          15 LOAD_GLOBAL              1 (False)
             18 RETURN_VALUE        

  8     >>   19 LOAD_GLOBAL              2 (True)
             22 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = object()
    if a is None:
        return False
    return True

>>> 
>>> timeit(a, number=1000000)
... 0.15754199028
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (object)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (a)

  6           9 LOAD_FAST                0 (a)
             12 LOAD_CONST               0 (None)
             15 COMPARE_OP               8 (is)
             18 POP_JUMP_IF_FALSE       25

  7          21 LOAD_GLOBAL              2 (False)
             24 RETURN_VALUE        

  8     >>   25 LOAD_GLOBAL              3 (True)
             28 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    a = object()
    if a:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.157824993134
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (object)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (a)

  6           9 LOAD_FAST                0 (a)
             12 POP_JUMP_IF_FALSE       19

  7          15 LOAD_GLOBAL              1 (True)
             18 RETURN_VALUE        

  8     >>   19 LOAD_GLOBAL              2 (False)
             22 RETURN_VALUE        

>>> 

超级慢的方式:

def a():
    a = object()
    if a is not None:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.181853055954
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (object)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (a)

  6           9 LOAD_FAST                0 (a)
             12 LOAD_CONST               0 (None)
             15 COMPARE_OP               9 (is not)
             18 POP_JUMP_IF_FALSE       25

  7          21 LOAD_GLOBAL              2 (True)
             24 RETURN_VALUE        

  8     >>   25 LOAD_GLOBAL              3 (False)
             28 RETURN_VALUE        

>>> 

测试用例 9

更快的方式:

def a():
    a = [1, 2, 3, 4, 5]
    s = 0
    for p, v in enumerate(a):
        s += p
        s += v
    return s

>>> 
>>> timeit(a, number=1000000)
... 0.738418102264
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (5)
             15 BUILD_LIST               5
             18 STORE_FAST               0 (a)

  6          21 LOAD_CONST               6 (0)
             24 STORE_FAST               1 (s)

  7          27 SETUP_LOOP              46 (to 76)
             30 LOAD_GLOBAL              0 (enumerate)
             33 LOAD_FAST                0 (a)
             36 CALL_FUNCTION            1
             39 GET_ITER            
        >>   40 FOR_ITER                32 (to 75)
             43 UNPACK_SEQUENCE          2
             46 STORE_FAST               2 (p)
             49 STORE_FAST               3 (v)

  8          52 LOAD_FAST                1 (s)
             55 LOAD_FAST                2 (p)
             58 INPLACE_ADD         
             59 STORE_FAST               1 (s)

  9          62 LOAD_FAST                1 (s)
             65 LOAD_FAST                3 (v)
             68 INPLACE_ADD         
             69 STORE_FAST               1 (s)
             72 JUMP_ABSOLUTE           40
        >>   75 POP_BLOCK           

 10     >>   76 LOAD_FAST                1 (s)
             79 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = [1, 2, 3, 4, 5]
    s = 0
    for i in range(len(a)):
        s += i
        s += a[i]
    return s

>>> 
>>> timeit(a, number=1000000)
... 0.800552845001
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (5)
             15 BUILD_LIST               5
             18 STORE_FAST               0 (a)

  6          21 LOAD_CONST               6 (0)
             24 STORE_FAST               1 (s)

  7          27 SETUP_LOOP              50 (to 80)
             30 LOAD_GLOBAL              0 (range)
             33 LOAD_GLOBAL              1 (len)
             36 LOAD_FAST                0 (a)
             39 CALL_FUNCTION            1
             42 CALL_FUNCTION            1
             45 GET_ITER            
        >>   46 FOR_ITER                30 (to 79)
             49 STORE_FAST               2 (i)

  8          52 LOAD_FAST                1 (s)
             55 LOAD_FAST                2 (i)
             58 INPLACE_ADD         
             59 STORE_FAST               1 (s)

  9          62 LOAD_FAST                1 (s)
             65 LOAD_FAST                0 (a)
             68 LOAD_FAST                2 (i)
             71 BINARY_SUBSCR       
             72 INPLACE_ADD         
             73 STORE_FAST               1 (s)
             76 JUMP_ABSOLUTE           46
        >>   79 POP_BLOCK           

 10     >>   80 LOAD_FAST                1 (s)
             83 RETURN_VALUE        

>>> 

测试用例 10

更快的方式:

def a():
    r = ''
    for i in range(10):
        r += str(i)
    return r

>>> 
>>> timeit(a, number=1000000)
... 1.63575387001
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 ('')
              3 STORE_FAST               0 (r)

  6           6 SETUP_LOOP              36 (to 45)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               2 (10)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                22 (to 44)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                0 (r)
             28 LOAD_GLOBAL              1 (str)
             31 LOAD_FAST                1 (i)
             34 CALL_FUNCTION            1
             37 INPLACE_ADD         
             38 STORE_FAST               0 (r)
             41 JUMP_ABSOLUTE           19
        >>   44 POP_BLOCK           

  8     >>   45 LOAD_FAST                0 (r)
             48 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    r = []
    for i in range(10):
        r.append(str(i))
    return ''.join(r)

>>> 
>>> timeit(a, number=1000000)
... 2.1280169487
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (r)

  6           6 SETUP_LOOP              39 (to 48)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (10)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                25 (to 47)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                0 (r)
             28 LOAD_ATTR                1 (append)
             31 LOAD_GLOBAL              2 (str)
             34 LOAD_FAST                1 (i)
             37 CALL_FUNCTION            1
             40 CALL_FUNCTION            1
             43 POP_TOP             
             44 JUMP_ABSOLUTE           19
        >>   47 POP_BLOCK           

  8     >>   48 LOAD_CONST               2 ('')
             51 LOAD_ATTR                3 (join)
             54 LOAD_FAST                0 (r)
             57 CALL_FUNCTION            1
             60 RETURN_VALUE        

>>> 

测试用例 11

更快的方式:

def a():
    a = 5
    b = 2
    c = 3
    return "%s" % (a*(b+c))

>>> 
>>> timeit(a, number=1000000)
... 0.229720830917
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (a)

  6           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  7          12 LOAD_CONST               3 (3)
             15 STORE_FAST               2 (c)

  8          18 LOAD_CONST               4 ('%s')
             21 LOAD_FAST                0 (a)
             24 LOAD_FAST                1 (b)
             27 LOAD_FAST                2 (c)
             30 BINARY_ADD          
             31 BINARY_MULTIPLY     
             32 BINARY_MODULO       
             33 RETURN_VALUE        

>>> 

更慢的方式:


def a(): a = 5 b = 2 c = 3 return str(a*(b+c)) >>> >>> timeit(a, number=1000000) ... 0.25043797493 >>> >>> dis(a) 5 0 LOAD_CONST 1 (5) 3 STORE_FAST 0 (a) 6 6 LOAD_CONST 2 (2) 9 STORE_FAST 1 (b) 7 12 LOAD_CONST 3 (3) 15 STORE_FAST 2 (c) 8 18 LOAD_GLOBAL 0 (str) 21 LOAD_FAST 0 (a) 24 LOAD_FAST 1 (b) 27 LOAD_FAST 2 (c) 30 BINARY_ADD 31 BINARY_MULTIPLY 32 CALL_FUNCTION 1 35 RETURN_VALUE >>>

最慢的方式:

def a():
    a = 5
    b = 2
    c = 3
    return "%d" % (a*(b+c))

>>> 
>>> timeit(a, number=1000000)
... 0.583065986633
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (a)

  6           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  7          12 LOAD_CONST               3 (3)
             15 STORE_FAST               2 (c)

  8          18 LOAD_CONST               4 ('%d')
             21 LOAD_FAST                0 (a)
             24 LOAD_FAST                1 (b)
             27 LOAD_FAST                2 (c)
             30 BINARY_ADD          
             31 BINARY_MULTIPLY     
             32 BINARY_MODULO       
             33 RETURN_VALUE        

>>> 


测试用例 12

更快的方式:

def a():
    a = [1, 2, 3, 4, 5]
    return len(a)

>>> 
>>> timeit(a, number=1000000)
... 0.194615840912
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (5)
             15 BUILD_LIST               5
             18 STORE_FAST               0 (a)

  6          21 LOAD_GLOBAL              0 (len)
             24 LOAD_FAST                0 (a)
             27 CALL_FUNCTION            1
             30 RETURN_VALUE        

>>> 


更慢的方式:

def a():
    a = [1, 2, 3, 4, 5]
    return a.__len__()

>>> 
>>> timeit(a, number=1000000)
... 0.220345020294
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 LOAD_CONST               5 (5)
             15 BUILD_LIST               5
             18 STORE_FAST               0 (a)

  6          21 LOAD_FAST                0 (a)
             24 LOAD_ATTR                0 (__len__)
             27 CALL_FUNCTION            0
             30 RETURN_VALUE        

>>> 

测试用例 13

更快的方式:

def a():
    a = 1
    b = 2
    c = 2
    d = 5
    return (a+b+c)*d

>>> 
>>> timeit(a, number=1000000)
... 0.170273065567
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  7          12 LOAD_CONST               2 (2)
             15 STORE_FAST               2 (c)

  8          18 LOAD_CONST               3 (5)
             21 STORE_FAST               3 (d)

  9          24 LOAD_FAST                0 (a)
             27 LOAD_FAST                1 (b)
             30 BINARY_ADD          
             31 LOAD_FAST                2 (c)
             34 BINARY_ADD          
             35 LOAD_FAST                3 (d)
             38 BINARY_MULTIPLY     
             39 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = 1
    b = 2
    c = 2
    d = 5
    return (a.__add__(b.__add__(c))).__mul__(d)

>>> 
>>> timeit(a, number=1000000)
... 0.363096952438
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  7          12 LOAD_CONST               2 (2)
             15 STORE_FAST               2 (c)

  8          18 LOAD_CONST               3 (5)
             21 STORE_FAST               3 (d)

  9          24 LOAD_FAST                0 (a)
             27 LOAD_ATTR                0 (__add__)
             30 LOAD_FAST                1 (b)
             33 LOAD_ATTR                0 (__add__)
             36 LOAD_FAST                2 (c)
             39 CALL_FUNCTION            1
             42 CALL_FUNCTION            1
             45 LOAD_ATTR                1 (__mul__)
             48 LOAD_FAST                3 (d)
             51 CALL_FUNCTION            1
             54 RETURN_VALUE        

>>> 

测试用例 14

更快的方式:

class Z():

    def __init__(self, v):
        self.v = v

    def __mul__(self, o):
        return Z(self.v * o.v)

    def __add__(self, o):
        return Z(self.v + o.v)


def a():
    a = Z(5)
    b = Z(2)
    c = Z(3)
    return (b.__add__(c)).__mul__(a)

>>> 
>>> timeit(a, number=1000000)
... 1.7775759697
>>> 
>>> dis(a)
 17           0 LOAD_GLOBAL              0 (Z)
              3 LOAD_CONST               1 (5)
              6 CALL_FUNCTION            1
              9 STORE_FAST               0 (a)

 18          12 LOAD_GLOBAL              0 (Z)
             15 LOAD_CONST               2 (2)
             18 CALL_FUNCTION            1
             21 STORE_FAST               1 (b)

 19          24 LOAD_GLOBAL              0 (Z)
             27 LOAD_CONST               3 (3)
             30 CALL_FUNCTION            1
             33 STORE_FAST               2 (c)

 20          36 LOAD_FAST                1 (b)
             39 LOAD_ATTR                1 (__add__)
             42 LOAD_FAST                2 (c)
             45 CALL_FUNCTION            1
             48 LOAD_ATTR                2 (__mul__)
             51 LOAD_FAST                0 (a)
             54 CALL_FUNCTION            1
             57 RETURN_VALUE        

>>> 

更慢的方式:

class Z():

    def __init__(self, v):
        self.v = v

    def __mul__(self, o):
        return Z(self.v * o.v)

    def __add__(self, o):
        return Z(self.v + o.v)


def a():
    a = Z(5)
    b = Z(2)
    c = Z(3)
    return (b + c) * a

>>> 
>>> timeit(a, number=1000000)
... 2.79053497314
>>> 
>>> dis(a)
 17           0 LOAD_GLOBAL              0 (Z)
              3 LOAD_CONST               1 (5)
              6 CALL_FUNCTION            1
              9 STORE_FAST               0 (a)

 18          12 LOAD_GLOBAL              0 (Z)
             15 LOAD_CONST               2 (2)
             18 CALL_FUNCTION            1
             21 STORE_FAST               1 (b)

 19          24 LOAD_GLOBAL              0 (Z)
             27 LOAD_CONST               3 (3)
             30 CALL_FUNCTION            1
             33 STORE_FAST               2 (c)

 20          36 LOAD_FAST                1 (b)
             39 LOAD_FAST                2 (c)
             42 BINARY_ADD          
             43 LOAD_FAST                0 (a)
             46 BINARY_MULTIPLY     
             47 RETURN_VALUE        

>>> 

测试用例 15

更快的方式:

def a():
    s = 0
    for i in range(50000):
        s += i
    return s


number = 100000

>>> 
>>> timeit(a, number=100000)
... 177.31340313
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (s)

  6           6 SETUP_LOOP              30 (to 39)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               2 (50000)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                16 (to 38)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                0 (s)
             28 LOAD_FAST                1 (i)
             31 INPLACE_ADD         
             32 STORE_FAST               0 (s)
             35 JUMP_ABSOLUTE           19
        >>   38 POP_BLOCK           

  8     >>   39 LOAD_FAST                0 (s)
             42 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    return sum(i for i in range(50000))


number = 100000

>>> 
>>> timeit(a, number=100000)
... 215.36849308
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (sum)
              3 LOAD_CONST               1 (<code object <genexpr> at 0x7f7357e854b0, file "/tmp/__pfw_test15_t2.py", line 5>)
              6 MAKE_FUNCTION            0
              9 LOAD_GLOBAL              1 (range)
             12 LOAD_CONST               2 (50000)
             15 CALL_FUNCTION            1
             18 GET_ITER            
             19 CALL_FUNCTION            1
             22 CALL_FUNCTION            1
             25 RETURN_VALUE        

>>> 

测试用例 16

更快的方式:

def a():
    return [i for i in range(1000)]


number = 100000

>>> 
>>> timeit(a, number=100000)
... 3.07614183426
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (1000)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                12 (to 28)
             16 STORE_FAST               0 (i)
             19 LOAD_FAST                0 (i)
             22 LIST_APPEND              2
             25 JUMP_ABSOLUTE           13
        >>   28 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    l = []
    for i in range(1000):
        l.append(i)
    return l


number = 100000

>>> 
>>> timeit(a, number=100000)
... 6.29185986519
>>> 
>>> dis(a)
  5           0 BUILD_LIST               0
              3 STORE_FAST               0 (l)

  6           6 SETUP_LOOP              33 (to 42)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (1000)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                19 (to 41)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                0 (l)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                1 (i)
             34 CALL_FUNCTION            1
             37 POP_TOP             
             38 JUMP_ABSOLUTE           19
        >>   41 POP_BLOCK           

  8     >>   42 LOAD_FAST                0 (l)
             45 RETURN_VALUE        

>>> 

测试用例 17

更快的方式:

def a():
    return {str(i): i*2 for i in range(100)}

>>> 
>>> timeit(a, number=1000000)
... 17.8982248306
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (<code object <dictcomp> at 0x7f81ea7854b0, file "/tmp/__pfw_test17_t3.py", line 5>)
              3 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              9 LOAD_CONST               2 (100)
             12 CALL_FUNCTION            1
             15 GET_ITER            
             16 CALL_FUNCTION            1
             19 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    d = {}
    for i in range(100):
        d[str(i)] = i*2
    return d

>>> 
>>> timeit(a, number=1000000)
... 18.513548851
>>> 
>>> dis(a)
  5           0 BUILD_MAP                0
              3 STORE_FAST               0 (d)

  6           6 SETUP_LOOP              40 (to 49)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (100)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                26 (to 48)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                1 (i)
             28 LOAD_CONST               2 (2)
             31 BINARY_MULTIPLY     
             32 LOAD_FAST                0 (d)
             35 LOAD_GLOBAL              1 (str)
             38 LOAD_FAST                1 (i)
             41 CALL_FUNCTION            1
             44 STORE_SUBSCR        
             45 JUMP_ABSOLUTE           19
        >>   48 POP_BLOCK           

  8     >>   49 LOAD_FAST                0 (d)
             52 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    d = {}
    for i in range(100):
        d.update({str(i): i*2})
    return d

>>> 
>>> timeit(a, number=1000000)
... 36.9908900261
>>> 
>>> dis(a)
  5           0 BUILD_MAP                0
              3 STORE_FAST               0 (d)

  6           6 SETUP_LOOP              50 (to 59)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (100)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                36 (to 58)
             22 STORE_FAST               1 (i)

  7          25 LOAD_FAST                0 (d)
             28 LOAD_ATTR                1 (update)
             31 BUILD_MAP                1
             34 LOAD_FAST                1 (i)
             37 LOAD_CONST               2 (2)
             40 BINARY_MULTIPLY     
             41 LOAD_GLOBAL              2 (str)
             44 LOAD_FAST                1 (i)
             47 CALL_FUNCTION            1
             50 STORE_MAP           
             51 CALL_FUNCTION            1
             54 POP_TOP             
             55 JUMP_ABSOLUTE           19
        >>   58 POP_BLOCK           

  8     >>   59 LOAD_FAST                0 (d)
             62 RETURN_VALUE        

>>> 

测试用例 18

更快的方式:

def a():
    l = range(50, -20, -2)
    return {p: v for p, v in enumerate(l)}

>>> 
>>> timeit(a, number=1000000)
... 2.82184195518
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (range)
              3 LOAD_CONST               1 (50)
              6 LOAD_CONST               2 (-20)
              9 LOAD_CONST               3 (-2)
             12 CALL_FUNCTION            3
             15 STORE_FAST               0 (l)

  6          18 LOAD_CONST               4 (<code object <dictcomp> at 0x7ff850f7a4b0, file "/tmp/__pfw_test18_t3.py", line 6>)
             21 MAKE_FUNCTION            0
             24 LOAD_GLOBAL              1 (enumerate)
             27 LOAD_FAST                0 (l)
             30 CALL_FUNCTION            1
             33 GET_ITER            
             34 CALL_FUNCTION            1
             37 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    l = range(50, -20, -2)
    d = {}
    for p, v in enumerate(l):
        d[p] = v
    return d

>>> 
>>> timeit(a, number=1000000)
... 3.04933786392
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (range)
              3 LOAD_CONST               1 (50)
              6 LOAD_CONST               2 (-20)
              9 LOAD_CONST               3 (-2)
             12 CALL_FUNCTION            3
             15 STORE_FAST               0 (l)

  6          18 BUILD_MAP                0
             21 STORE_FAST               1 (d)

  7          24 SETUP_LOOP              36 (to 63)
             27 LOAD_GLOBAL              1 (enumerate)
             30 LOAD_FAST                0 (l)
             33 CALL_FUNCTION            1
             36 GET_ITER            
        >>   37 FOR_ITER                22 (to 62)
             40 UNPACK_SEQUENCE          2
             43 STORE_FAST               2 (p)
             46 STORE_FAST               3 (v)

  8          49 LOAD_FAST                3 (v)
             52 LOAD_FAST                1 (d)
             55 LOAD_FAST                2 (p)
             58 STORE_SUBSCR        
             59 JUMP_ABSOLUTE           37
        >>   62 POP_BLOCK           

  9     >>   63 LOAD_FAST                1 (d)
             66 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    l = range(50, -20, -2)
    d = {}
    for p, v in enumerate(l):
        d.update({p: v})
    return d

>>> 
>>> timeit(a, number=1000000)
... 9.87823104858
>>> 
>>> dis(a)
  5           0 LOAD_GLOBAL              0 (range)
              3 LOAD_CONST               1 (50)
              6 LOAD_CONST               2 (-20)
              9 LOAD_CONST               3 (-2)
             12 CALL_FUNCTION            3
             15 STORE_FAST               0 (l)

  6          18 BUILD_MAP                0
             21 STORE_FAST               1 (d)

  7          24 SETUP_LOOP              46 (to 73)
             27 LOAD_GLOBAL              1 (enumerate)
             30 LOAD_FAST                0 (l)
             33 CALL_FUNCTION            1
             36 GET_ITER            
        >>   37 FOR_ITER                32 (to 72)
             40 UNPACK_SEQUENCE          2
             43 STORE_FAST               2 (p)
             46 STORE_FAST               3 (v)

  8          49 LOAD_FAST                1 (d)
             52 LOAD_ATTR                2 (update)
             55 BUILD_MAP                1
             58 LOAD_FAST                3 (v)
             61 LOAD_FAST                2 (p)
             64 STORE_MAP           
             65 CALL_FUNCTION            1
             68 POP_TOP             
             69 JUMP_ABSOLUTE           37
        >>   72 POP_BLOCK           

  9     >>   73 LOAD_FAST                1 (d)
             76 RETURN_VALUE        

>>> 

测试用例 19

更快的方式:

def a():
    a = 1
    if a == 1 or a == 2 or a == 3:
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.100009918213
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               1 (1)
             12 COMPARE_OP               2 (==)
             15 POP_JUMP_IF_TRUE        42
             18 LOAD_FAST                0 (a)
             21 LOAD_CONST               2 (2)
             24 COMPARE_OP               2 (==)
             27 POP_JUMP_IF_TRUE        42
             30 LOAD_FAST                0 (a)
             33 LOAD_CONST               3 (3)
             36 COMPARE_OP               2 (==)
             39 POP_JUMP_IF_FALSE       46

  7     >>   42 LOAD_GLOBAL              0 (True)
             45 RETURN_VALUE        

  8     >>   46 LOAD_GLOBAL              1 (False)
             49 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = 1
    if a in (1, 2, 3):
        return True
    return False

>>> 
>>> timeit(a, number=1000000)
... 0.105048894882
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (a)

  6           6 LOAD_FAST                0 (a)
              9 LOAD_CONST               4 ((1, 2, 3))
             12 COMPARE_OP               6 (in)
             15 POP_JUMP_IF_FALSE       22

  7          18 LOAD_GLOBAL              0 (True)
             21 RETURN_VALUE        

  8     >>   22 LOAD_GLOBAL              1 (False)
             25 RETURN_VALUE        

>>> 

测试用例 20

更快的方式:


更慢的方式:


最慢的方式:


测试用例 21

更快的方式:

def a():
    return ''.join(map(str, xrange(10)))

>>> 
>>> timeit(a, number=1000000)
... 1.28661704063
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 ('')
              3 LOAD_ATTR                0 (join)
              6 LOAD_GLOBAL              1 (map)
              9 LOAD_GLOBAL              2 (str)
             12 LOAD_GLOBAL              3 (xrange)
             15 LOAD_CONST               2 (10)
             18 CALL_FUNCTION            1
             21 CALL_FUNCTION            2
             24 CALL_FUNCTION            1
             27 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    return ''.join(map(str, range(10)))

>>> 
>>> timeit(a, number=1000000)
... 1.29610896111
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 ('')
              3 LOAD_ATTR                0 (join)
              6 LOAD_GLOBAL              1 (map)
              9 LOAD_GLOBAL              2 (str)
             12 LOAD_GLOBAL              3 (range)
             15 LOAD_CONST               2 (10)
             18 CALL_FUNCTION            1
             21 CALL_FUNCTION            2
             24 CALL_FUNCTION            1
             27 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    r = ''
    for i in range(10):
        r = '%s%s' % (r, str(i))
    return r

>>> 
>>> timeit(a, number=1000000)
... 2.74961709976
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 ('')
              3 STORE_FAST               0 (r)

  6           6 SETUP_LOOP              42 (to 51)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               2 (10)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                28 (to 50)
             22 STORE_FAST               1 (i)

  7          25 LOAD_CONST               3 ('%s%s')
             28 LOAD_FAST                0 (r)
             31 LOAD_GLOBAL              1 (str)
             34 LOAD_FAST                1 (i)
             37 CALL_FUNCTION            1
             40 BUILD_TUPLE              2
             43 BINARY_MODULO       
             44 STORE_FAST               0 (r)
             47 JUMP_ABSOLUTE           19
        >>   50 POP_BLOCK           

  8     >>   51 LOAD_FAST                0 (r)
             54 RETURN_VALUE        

>>> 

测试用例 22

更快的方式:

def a(n=25):
    a, b = 0, 1
    for i in range(n):
        x = a + b
        a = b
        b = x
    return a

>>> 
>>> timeit(a, number=1000000)
... 1.34775996208
>>> 
>>> dis(a)
  5           0 LOAD_CONST               3 ((0, 1))
              3 UNPACK_SEQUENCE          2
              6 STORE_FAST               1 (a)
              9 STORE_FAST               2 (b)

  6          12 SETUP_LOOP              42 (to 57)
             15 LOAD_GLOBAL              0 (range)
             18 LOAD_FAST                0 (n)
             21 CALL_FUNCTION            1
             24 GET_ITER            
        >>   25 FOR_ITER                28 (to 56)
             28 STORE_FAST               3 (i)

  7          31 LOAD_FAST                1 (a)
             34 LOAD_FAST                2 (b)
             37 BINARY_ADD          
             38 STORE_FAST               4 (x)

  8          41 LOAD_FAST                2 (b)
             44 STORE_FAST               1 (a)

  9          47 LOAD_FAST                4 (x)
             50 STORE_FAST               2 (b)
             53 JUMP_ABSOLUTE           25
        >>   56 POP_BLOCK           

 10     >>   57 LOAD_FAST                1 (a)
             60 RETURN_VALUE        

>>> 

更慢的方式:

def a(n=25):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a + b
    return a

>>> 
>>> timeit(a, number=1000000)
... 1.46058106422
>>> 
>>> dis(a)
  5           0 LOAD_CONST               3 ((0, 1))
              3 UNPACK_SEQUENCE          2
              6 STORE_FAST               1 (a)
              9 STORE_FAST               2 (b)

  6          12 SETUP_LOOP              37 (to 52)
             15 LOAD_GLOBAL              0 (range)
             18 LOAD_FAST                0 (n)
             21 CALL_FUNCTION            1
             24 GET_ITER            
        >>   25 FOR_ITER                23 (to 51)
             28 STORE_FAST               3 (i)

  7          31 LOAD_FAST                2 (b)
             34 LOAD_FAST                1 (a)
             37 LOAD_FAST                2 (b)
             40 BINARY_ADD          
             41 ROT_TWO             
             42 STORE_FAST               1 (a)
             45 STORE_FAST               2 (b)
             48 JUMP_ABSOLUTE           25
        >>   51 POP_BLOCK           

  8     >>   52 LOAD_FAST                1 (a)
             55 RETURN_VALUE        

>>> 

测试用例 23

更快的方式:

def a():
    x, y, z, w, k = 0, 0, 0, 0, 0
    return x, y, z, w, k

>>> 
>>> timeit(a, number=1000000)
... 0.168544054031
>>> 
>>> dis(a)
  5           0 LOAD_CONST               2 ((0, 0, 0, 0, 0))
              3 UNPACK_SEQUENCE          5
              6 STORE_FAST               0 (x)
              9 STORE_FAST               1 (y)
             12 STORE_FAST               2 (z)
             15 STORE_FAST               3 (w)
             18 STORE_FAST               4 (k)

  6          21 LOAD_FAST                0 (x)
             24 LOAD_FAST                1 (y)
             27 LOAD_FAST                2 (z)
             30 LOAD_FAST                3 (w)
             33 LOAD_FAST                4 (k)
             36 BUILD_TUPLE              5
             39 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    x = 0
    y = 0
    z = 0
    w = 0
    k = 0
    return x, y, z, w, k

>>> 
>>> timeit(a, number=1000000)
... 0.174968957901
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (x)

  6           6 LOAD_CONST               1 (0)
              9 STORE_FAST               1 (y)

  7          12 LOAD_CONST               1 (0)
             15 STORE_FAST               2 (z)

  8          18 LOAD_CONST               1 (0)
             21 STORE_FAST               3 (w)

  9          24 LOAD_CONST               1 (0)
             27 STORE_FAST               4 (k)

 10          30 LOAD_FAST                0 (x)
             33 LOAD_FAST                1 (y)
             36 LOAD_FAST                2 (z)
             39 LOAD_FAST                3 (w)
             42 LOAD_FAST                4 (k)
             45 BUILD_TUPLE              5
             48 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    x = y = z = w = k = 0
    return x, y, z, w, k

>>> 
>>> timeit(a, number=1000000)
... 0.205312013626
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (0)
              3 DUP_TOP             
              4 STORE_FAST               0 (x)
              7 DUP_TOP             
              8 STORE_FAST               1 (y)
             11 DUP_TOP             
             12 STORE_FAST               2 (z)
             15 DUP_TOP             
             16 STORE_FAST               3 (w)
             19 STORE_FAST               4 (k)

  6          22 LOAD_FAST                0 (x)
             25 LOAD_FAST                1 (y)
             28 LOAD_FAST                2 (z)
             31 LOAD_FAST                3 (w)
             34 LOAD_FAST                4 (k)
             37 BUILD_TUPLE              5
             40 RETURN_VALUE        

>>> 

测试用例 24

更快的方式:

def a():
    a = [[1, 2, 3], [2, 3, 4], [4, 5, 6]]
    b = {k: v for x, k, v in a}
    return b

>>> 
>>> timeit(a, number=1000000)
... 0.717478990555
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 BUILD_LIST               3
             12 LOAD_CONST               2 (2)
             15 LOAD_CONST               3 (3)
             18 LOAD_CONST               4 (4)
             21 BUILD_LIST               3
             24 LOAD_CONST               4 (4)
             27 LOAD_CONST               5 (5)
             30 LOAD_CONST               6 (6)
             33 BUILD_LIST               3
             36 BUILD_LIST               3
             39 STORE_FAST               0 (a)

  6          42 LOAD_CONST               7 (<code object <dictcomp> at 0x7f9e6e6b94b0, file "/tmp/__pfw_test24_t3.py", line 6>)
             45 MAKE_FUNCTION            0
             48 LOAD_FAST                0 (a)
             51 GET_ITER            
             52 CALL_FUNCTION            1
             55 STORE_FAST               1 (b)

  7          58 LOAD_FAST                1 (b)
             61 RETURN_VALUE        

>>> 

更慢的方式:

def a():
    a = [[1, 2, 3], [2, 3, 4], [4, 5, 6]]
    b = {x[1]: x[2] for x in a}
    return b

>>> 
>>> timeit(a, number=1000000)
... 0.744184017181
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 BUILD_LIST               3
             12 LOAD_CONST               2 (2)
             15 LOAD_CONST               3 (3)
             18 LOAD_CONST               4 (4)
             21 BUILD_LIST               3
             24 LOAD_CONST               4 (4)
             27 LOAD_CONST               5 (5)
             30 LOAD_CONST               6 (6)
             33 BUILD_LIST               3
             36 BUILD_LIST               3
             39 STORE_FAST               0 (a)

  6          42 LOAD_CONST               7 (<code object <dictcomp> at 0x7fcc514754b0, file "/tmp/__pfw_test24_t1.py", line 6>)
             45 MAKE_FUNCTION            0
             48 LOAD_FAST                0 (a)
             51 GET_ITER            
             52 CALL_FUNCTION            1
             55 STORE_FAST               1 (b)

  7          58 LOAD_FAST                1 (b)
             61 RETURN_VALUE        

>>> 

最慢的方式:

def a():
    a = [[1, 2, 3], [2, 3, 4], [4, 5, 6]]
    b = dict((x, y)for w, x, y in a)
    return b

>>> 
>>> timeit(a, number=1000000)
... 1.32197403908
>>> 
>>> dis(a)
  5           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 BUILD_LIST               3
             12 LOAD_CONST               2 (2)
             15 LOAD_CONST               3 (3)
             18 LOAD_CONST               4 (4)
             21 BUILD_LIST               3
             24 LOAD_CONST               4 (4)
             27 LOAD_CONST               5 (5)
             30 LOAD_CONST               6 (6)
             33 BUILD_LIST               3
             36 BUILD_LIST               3
             39 STORE_FAST               0 (a)

  6          42 LOAD_GLOBAL              0 (dict)
             45 LOAD_CONST               7 (<code object <genexpr> at 0x7f5ea06174b0, file "/tmp/__pfw_test24_t2.py", line 6>)
             48 MAKE_FUNCTION            0
             51 LOAD_FAST                0 (a)
             54 GET_ITER            
             55 CALL_FUNCTION            1
             58 CALL_FUNCTION            1
             61 STORE_FAST               1 (b)

  7          64 LOAD_FAST                1 (b)
             67 RETURN_VALUE        

>>> 

查看原文

Zair 收藏了问题 · 2014-09-07

你经常访问的技术社区或者技术博客(IT类)有哪些?

想做个统计,然后就是想为之后的一些事情做准备,SegmentFault就不说了,现在每天都在看
欢迎大家集思广益,整理收集一下

国内经常访问的:

  1. 阮一峰的博客:http://www.ruanyifeng.com/blog/
  2. 程序员杂志:技术改变世界,创新驱动中国 http://www.programmer.com.cn/
  3. 西乔的九卦:程序员漫画 http://blog.xiqiao.info/category/prog...
  4. InfoQ中文站:http://www.infoq.com/cn/
  5. Mind Hacks:《暗时间》作者 http://mindhacks.cn/

国外经常看的:

  1. Hacker News:ycombinator旗下网站 http://news.ycombinator.com/news
  2. SO :http://stackoverflow.com/
  3. Github: http://github.com/

Zair 发布了文章 · 2014-09-06

使用注册表优化终端、编辑器的中英字体混合显示,如「Consolas + 雅黑」

在终端、cmd、编辑器中偶尔会有中文字符出现,Windows下默认的点阵字体「宋体」和等宽英文字符放在一起非常违和。一个解决方法是下载混合字体,比如「Consolas + YAHEI hybrid」,「Source Code Pro + YAHEI hybrid」。但是这些字体组合毕竟有限,如果想用「Anonymous Pro + 幼圆」、或者更改字重、使用斜体该怎么办呢?这时便要用到注册表的FontLink功能了。

FontLink,顾名思义,是将某个字体未包含的字符映射到另一个字体上。比如编辑器中设定默认字体是「Consolas」,如果文件中有汉字字符,Windows本来默认显示为「宋体」,但是FontLink设置了「雅黑」,便可以用「雅黑」来显示。

以「Consolas + 雅黑」为例,下面是实现方法:

  1. 按下Win+R打开「运行」,输入regedit点击确定,开启「注册表」;
  2. 定位到如下位置;

    HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink

  3. 找到Consolas项,双击打开,在「数值数据」文本框内输入以下内容后点击确定;

    MSYH.TTF,205,154
    MSYH.TTF

  4. 注销或重启计算机。


传送门

  1. 喜欢用Consolas + 雅黑么?我也喜欢,但是不用Yahei Consolas Hybrid
  2. 用Monaco和微软雅黑字体美化cmd和PowerShell
查看原文

赞 0 收藏 4 评论 0

Zair 发布了文章 · 2014-09-05

R: 对已处理数据绘制按比例分布的等高柱状图

等高分布式柱状图

R代码如下:

#输入数据
s1=c(1:3)
s2=c(2:4)
s3=c(3:5)
#建立数据集
d=data.frame(s1,s2,s3,row.names=c('miffy','kitty','tommy'))
#转换数据集结构
library(reshape2)
df=melt(as.matrix(d))
#使用ggplot2绘图
library(ggplot2)
ggplot(df,aes(Var2,value,fill=Var1))+geom_bar(stat="identity",position="fill")

特别注意数据集ddf的区别,在命令行下键入名称后回车查看:

>d
      s1 s2 s3
miffy  1  2  3
kitty  2  3  4
tommy  3  4  5
>df
   Var1 Var2 value
1 miffy   s1     1
2 kitty   s1     2
3 tommy   s1     3
4 miffy   s2     2
5 kitty   s2     3
6 tommy   s2     4
7 miffy   s3     3
8 kitty   s3     4
9 tommy   s3     5

特别感谢YGC:《使用ggplot2画图》,我只是代码的搬运工。

查看原文

赞 0 收藏 2 评论 0

Zair 评论了文章 · 2014-08-26

vim中括号的自动补全

认证与成就

  • 获得 10 次点赞
  • 获得 7 枚徽章 获得 0 枚金徽章, 获得 2 枚银徽章, 获得 5 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2014-04-18
个人主页被 482 人浏览