相关疑难解决方法(0)

创建一个包含30个字符的随机字符串的最轻量级方法是什么,如下所示？

ufhy3skj5nca0d2dfh9hwd2tbk9sw1

和十六进制的十六进制数字如下？

8c6f78ac23b4a7b8c0182d7a89e9b1

我想了解如何使用dis(Python字节码的解析器).具体来说,如何解释dis.dis(或dis.disassemble)的输出？

.

这是一个非常具体的例子(在Python 2.7.3中):

dis.dis("heapq.nsmallest(d,3)")

      0 BUILD_SET             24933
      3 JUMP_IF_TRUE_OR_POP   11889
      6 JUMP_FORWARD          28019 (to 28028)
      9 STORE_GLOBAL          27756 (27756)
     12 LOAD_NAME             29811 (29811)
     15 STORE_SLICE+0  
     16 LOAD_CONST            13100 (13100)
     19 STORE_SLICE+1

我看到JUMP_IF_TRUE_OR_POP等等是字节码指令(虽然有趣的是,BUILD_SET这个列表中没有出现,但我希望它可以工作BUILD_TUPLE).我认为右边的数字是内存分配,左边的数字是转到数字......我注意到它们每次几乎增加3(但不完全).

如果我dis.dis("heapq.nsmallest(d,3)")在函数内部换行:

def f_heapq_nsmallest(d,n):
    return heapq.nsmallest(d,n)

dis.dis("f_heapq(d,3)")

      0 BUILD_TUPLE            26719
      3 LOAD_NAME              28769 (28769)
      6 JUMP_ABSOLUTE          25640
      9 <44>                                      # what is <44> ?  
     10 DELETE_SLICE+1 
     11 STORE_SLICE+1 

令人惊讶的是,我发现startswith速度比in:

In [10]: s="ABCD"*10

In [11]: %timeit s.startswith("XYZ")
1000000 loops, best of 3: 307 ns per loop

In [12]: %timeit "XYZ" in s
10000000 loops, best of 3: 81.7 ns per loop

众所周知,in操作需要搜索整个字符串,startswith只需要检查前几个字符,所以startswith应该更有效率.

什么时候s足够大,startswith速度更快:

In [13]: s="ABCD"*200

In [14]: %timeit s.startswith("XYZ")
1000000 loops, best of 3: 306 ns per loop

In [15]: %timeit "XYZ" in s
1000000 loops, best of 3: 666 ns per loop

所以看起来调用 …

在pandas的手册中,有关于索引的示例:

In [653]: criterion = df2['a'].map(lambda x: x.startswith('t'))
In [654]: df2[criterion]

然后韦斯写道:

**# equivalent but slower**
In [655]: df2[[x.startswith('t') for x in df2['a']]]

谁能在这里解释一下为什么地图方法更快？这是一个python功能还是这是一个熊猫功能？

至少有两种方法可以在Python中反转列表,但迭代器方法要快得多(至少在Python 2.7.x中).我想了解这种速度差异的原因.

>>> x = range(1000)
>>> %timeit x[::-1]
100000 loops, best of 3: 2.99 us per loop
>>> %timeit reversed(x)
10000000 loops, best of 3: 169 ns per loop

我怀疑速度差异至少是由于以下因素:

1. reversed 是用C写的
2. reversed 是一个迭代器,所以内存开销较少

我试图使用该dis模块来更好地了解这些操作,但它没有太大帮助.我不得不将这些操作放在一个函数中来反汇编它们.

>> def reverselist(_list):
...     return _list[::-1]
... 
>>> dis.dis(reverselist)
  2           0 LOAD_FAST                0 (_list)
              3 LOAD_CONST               0 (None)
              6 LOAD_CONST               0 (None)
              9 LOAD_CONST               1 (-1)
             12 BUILD_SLICE              3
             15 BINARY_SUBSCR       
             16 RETURN_VALUE
>>> def reversed_iter(_list):
...     return reversed(_list)
... 
>>> dis.dis(reversed_iter) …

我的目的是对字符串列表进行排序,其中单词必须按字母顺序排序.除了以"s"开头的单词应该在列表的开头(它们也应该排序),然后是其他单词.

以下功能对我来说就是这样.

def mysort(words):
    mylist1 = sorted([i for i in words if i[:1] == "s"])
    mylist2 = sorted([i for i in words if i[:1] != "s"])
    list = mylist1 + mylist2
    return list

我只是在寻找替代方法来实现这一点,或者任何人都可以找到上述代码的任何问题.