标签: python-internals

我试图text.translate()在Python 3.4中删除给定字符串中不需要的字符.

最小的代码是:

import sys 
s = 'abcde12345@#@$#%$'
mapper = dict.fromkeys(i for i in range(sys.maxunicode) if chr(i) in '@#$')
print(s.translate(mapper))

它按预期工作.但是,在Python 3.4和Python 3.5中执行相同的程序会产生很大的差异.

计算时间的代码是

python3 -m timeit -s "import sys;s = 'abcde12345@#@$#%$'*1000 ; mapper = dict.fromkeys(i for i in range(sys.maxunicode) if chr(i) in '@#$'); "   "s.translate(mapper)"

Python 3.4程序需要1.3毫秒,而Python 3.5中的相同程序只需要26.4μs.

与Python 3.4相比,Python 3.5有哪些改进使其更快？

有没有办法看到内置函数如何在python中工作？我不是指如何使用它们,而是它们是如何构建的,排序或枚举背后的代码是什么......？

以下两个代码片段之间是否存在任何最终差异？第一个为函数中的变量赋值,然后返回该变量.第二个函数只是直接返回值.

Python会将它们转换为等效的字节码吗？其中一个更快吗？

案例1:

def func():
    a = 42
    return a

案例2:

def func():
    return 42

一个tuple发生在Python的内存空间少:

>>> a = (1,2,3)
>>> a.__sizeof__()
48

而lists需要更多的内存空间:

>>> b = [1,2,3]
>>> b.__sizeof__()
64

Python内存管理内部会发生什么？

Pythonint是封装实际数值的对象。我们可以修改这个值吗，例如将对象的值设置1为 2？那么这就1 == 2变成了True？

我一直在玩Python的哈希函数.对于小整数,它hash(n) == n总是出现.然而,这并没有扩展到大数:

>>> hash(2**100) == 2**100
False

我并不感到惊讶,我理解哈希需要一个有限范围的值.这个范围是多少？

我尝试使用二进制搜索来找到最小的数字hash(n) != n

>>> import codejamhelpers # pip install codejamhelpers
>>> help(codejamhelpers.binary_search)
Help on function binary_search in module codejamhelpers.binary_search:

binary_search(f, t)
    Given an increasing function :math:`f`, find the greatest non-negative integer :math:`n` such that :math:`f(n) \le t`. If :math:`f(n) > t` for all :math:`n \ge 0`, return None.

>>> f = lambda n: int(hash(n) != n)
>>> n = codejamhelpers.binary_search(f, 0)
>>> hash(n)
2305843009213693950 …

鉴于比雷埃夫斯对另一个问题的回答,我们有这个

x = tuple(set([1, "a", "b", "c", "z", "f"]))
y = tuple(set(["a", "b", "c", "z", "f", 1]))
print(x == y)

True在启用哈希随机化的情况下打印大约85%的时间.为什么85%？

sort()Python使用的内置方法是什么算法？是否可以查看该方法的代码？

我发现它max比sortPython 2和3中的函数慢.

Python 2

$ python -m timeit -s 'import random;a=range(10000);random.shuffle(a)' 'a.sort();a[-1]'
1000 loops, best of 3: 239 usec per loop
$ python -m timeit -s 'import random;a=range(10000);random.shuffle(a)' 'max(a)'        
1000 loops, best of 3: 342 usec per loop

Python 3

$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'a.sort();a[-1]'
1000 loops, best of 3: 252 usec per loop
$ python3 -m timeit -s 'import random;a=list(range(10000));random.shuffle(a)' 'max(a)'
1000 loops, best of 3: 371 usec per loop

为什么是 …

复制洗牌range(10**6)清单十次需要大约0.18秒:(这是五次运行)

0.175597017661
0.173731403198
0.178601711594
0.180330912952
0.180811964451

将未洗牌的列表复制十次需要大约0.05秒:

0.058402235973
0.0505464636856
0.0509734306934
0.0526022752744
0.0513324916184

这是我的测试代码:

from timeit import timeit
import random

a = range(10**6)
random.shuffle(a)    # Remove this for the second test.
a = list(a)          # Just an attempt to "normalize" the list.
for _ in range(5):
    print timeit(lambda: list(a), number=10)

我也尝试过复制a[:],结果相似(即速度差异很大)

为什么速度差异很大？我知道并理解着名的速度差异为什么处理排序数组比未排序数组更快？例如,但在这里我的处理没有决定.它只是盲目地复制列表中的引用,不是吗？

我在Windows 10上使用Python 2.7.12.

编辑:现在尝试使用Python 3.5.2,结果几乎相同(在0.17秒内一直洗牌,在0.05秒内一直未洗牌).这是代码:

a = list(range(10**6))
random.shuffle(a)
a = list(a)
for _ in range(5):
    print(timeit(lambda: list(a), number=10))