相关疑难解决方法(0)

这里有两个测量值：

timeit.timeit('"toto"=="1234"', number=100000000)
1.8320042459999968
timeit.timeit('"toto"=="toto"', number=100000000)
1.4517491540000265

正如您所看到的，比较两个匹配的字符串比比较两个大小相同但不匹配的字符串要快。这是相当令人不安的：在字符串比较期间，我相信 Python 正在逐个字符地测试字符串，因此"toto"=="toto"测试时间应该比"toto"=="1234"它需要针对一个不匹配比较进行四次测试的时间更长。也许比较是基于哈希的，但在这种情况下，两次比较的时间应该相同。

为什么？

为什么执行startwith比切片慢？

In [1]: x = 'foobar'

In [2]: y = 'foo'

In [3]: %timeit x.startswith(y)
1000000 loops, best of 3: 321 ns per loop

In [4]: %timeit x[:3] == y
10000000 loops, best of 3: 164 ns per loop

令人惊讶的是,即使包括计算长度,切片仍然显得更快:

In [5]: %timeit x[:len(y)] == y
1000000 loops, best of 3: 251 ns per loop

注意:此行为的第一部分在Python for Data Analysis(第3章)中有说明,但没有提供解释.

.

如果有用:这是C代码startswith ; 这是输出dis.dis:

In [6]: import dis

In [7]: dis_it = lambda …

我试图更清楚地理解python编译器/解释器进程.不幸的是,我没有参加口译课,也没有读过很多关于它们的内容.

基本上,我现在理解的是.py文件中的Python代码首先编译成python字节码(我假设偶尔会看到.pyc文件？).接下来,字节码被编译成机器代码,这是处理器实际理解的语言.差不多,我已经读过这个帖子为什么python在解释前将源代码编译成字节码？

有人能给我一个很好的解释整个过程,记住我对编译器/解释器的了解几乎不存在吗？或者,如果这不可能,也许给我一些资源,快速概述编译器/解释器？

谢谢

我在理解Python的字节码及其dis模块时遇到了很多困难.

import dis
def func():
   x = 1
dis.dis(func)

在解释器中输入上面的代码会产生以下输出:

    0 LOAD_CONST                  1(1)
    3 STORE_FAST                  0(x)
    6 LOAD_CONST                  0(NONE)
    9 RETURN_VALUE

例如:

是什么意思LOAD_CONST,STORE_FAST和喜欢的数字0,3,6和9？

我将非常感谢您可以找到此信息的特定资源.

在可用于创建空Python列表/词典的两种语法形式之间是否存在任何明显的差异,即

l = list()
l = []

和:

d = dict()
d = {}

我想知道使用一个是否优于另一个.

我正在学习Python,现在我正在讨论范围和非本地语句.在某些时候,我以为我想到了这一切,但随后非本地人来了,打破了一切.

示例1:

print( "let's begin" )
def a():
    def b():
        nonlocal x
        x = 20
    b()

a()

自然运行失败.
更有趣的是,print()不会被执行.为什么？.

我的理解是封闭def a()在执行之前print()不会执行,嵌套def b()只在a()被调用时执行.我很迷惑...

好的,让我们尝试第2个例子:

print( "let's begin" )
def a():
    if False: x = 10
    def b():
        nonlocal x
        x = 20
    b()

a()

Aaand ......它运行良好.Whaaat？这是怎么解决的？x = 10在函数a中永远不会执行!

我的理解是在运行时评估和执行非本地语句,搜索封闭函数的调用上下文并将本地名称绑定x到某个特定的"外部" x.如果x外部函数中没有- 引发异常.再次,在运行时.

但现在看来这是在语法分析时完成的,非常愚蠢的检查"看看外部函数x = blah,如果有这样的东西 - 我们很好",即使x = blah从未执行过...... …

我正在尝试使用python的dis库来试验和理解性能.以下是我尝试过的实验,结果如下.

import dis

def myfunc1(dictionary):
    t = tuple(dictionary.items())
    return t

def myfunc2(dictionary, func=tuple):
    t = func(dictionary.items())
    return t

>>> dis.dis(myfunc1)

  4           0 LOAD_GLOBAL              0 (tuple)
              3 LOAD_FAST                0 (dictionary)
              6 LOAD_ATTR                1 (items)
              9 CALL_FUNCTION            0
             12 CALL_FUNCTION            1
             15 STORE_FAST               1 (t)

  5          18 LOAD_FAST                1 (t)
             21 RETURN_VALUE 

>>> dis.dis(myfunc2)

  4           0 LOAD_FAST                1 (func)
              3 LOAD_FAST                0 (dictionary)
              6 LOAD_ATTR                0 (items)
              9 CALL_FUNCTION            0
             12 CALL_FUNCTION            1
             15 STORE_FAST               2 (t)

  5          18 LOAD_FAST …

x = func(*(xa,) + args)
y = func(*((xc,) + args)) 

其中args是一个数组,函数定义是:

def func(lamb, data):
    # statements

我了解到了*args,但我找不到这些线之间的确切差异.

假设我有一个函数,我想分析确切步数的运行时间:

def function(L):
    print ("Hello")
    i = 0                 # 1 step
    while i < len(L):     # 3 steps
        print (L[i] + 1)
        i += 2            # 2 steps
    print ("Goodbye")

我想知道印刷语句是否算作一个步骤？

这两个函数在调用时似乎返回相同的值.但是,我想知道在某些情况下2号是否会引发错误？这样做是不好的做法吗？

1号:

def not_sum_to_ten(num1, num2):
  if num1 + num2 != 10:
    return True
  else:
    return False

2号:

def not_sum_to_ten(num1, num2):
  if num1 + num2 != 10:
    return True
  return False

感谢您分享您的知识!