标签: python-internals

考虑以下代码：

主要.py

import asyncio
import websockets


async def echo(websocket):
    async for message in websocket:
        await websocket.send(message)
        print(message)


async def main():
    async with websockets.serve(echo, "localhost", 8765):
        await asyncio.Future()  # run forever

if __name__ == '__main__':
    asyncio.run(main())

其他.py

import asyncio
import json

import websockets

tasks = set()


async def run_job(i):
    await asyncio.sleep(0.)
    print(f"I'm job number {i}")


async def bunch_of_tasks(ws):
    for i in range(10):
        task = asyncio.create_task(run_job(i), name=f'job-{i}')
        tasks.add(task)
        task.add_done_callback(tasks.discard)
        print(f'had a nice sleep! now my value is {i}')
        # await asyncio.sleep(0.)
        await …

在python中,我可以创建一个没有类语句的类:

MyClass = type('X', (object,), dict(a=1))

有没有办法创建一个没有'def'的函数？多数民众赞成就是......

d={} # func from string
exec'''\
def synthetics(s):
    return s*s+1
''' in d

>>> d.keys()
['__builtins__', 'synthetics']
>>> d['synthetics']
<function synthetics at 0x00D09E70>
>>> foo = d['synthetics']
>>> foo(1)
2

我知道我的意思似乎微不足道,但我无法弄清楚为什么'stop'不等于零,因为'start'值已经被覆盖了.但是当我模拟同一个场景时,它确实覆盖了它.我错过了什么吗？

def interval(start, stop =None, step = 1 ):
    'Imitates range() for step >0 '
    if stop is None:
        start, stop = 0, start #since start is already 0, why isn't stop as well?
        print start,stop , step
    result = []
    i = start
    while i< stop:
        result.append(i)
        i+=step 
    return result

找不到这个.试图比较2个值,但它们不能相等.就我而言,它们可以(通常是)大于或小于.

我应该使用:

if a <> b:
   dostuff

要么

if a != b:
   dostuff

这个页面说它们是相似的,这意味着它们至少有些不同.

Python的strip()的运行时是什么？

由于对于单个char,remove是O(n),对于字符串是条带O(n ^ 2)吗？

我看到了建议(参见例如,在C中使用移位运算符进行乘法和除法实际上更快吗？),你不应该用移位运算符手动替换乘法,因为编译器必须自动执行,移位运算符会降低可读性.我写了一个简单的测试来检查这个:

import numpy as np
import time

array1 = np.random.randint(size=10 ** 6, low=0, high=10 ** 5)
array2 = np.zeros((10 ** 6,), dtype=np.int)

total = 0.0
for i in range(100):
    start = time.clock()
    for j in range(len(array2)):
        array2[j] = array1[j] * 2
    total += time.clock() - start
print("*2 time = " + str(round(total / 10, 5)) + " ms")


total = 0.0
for i in range(100):
    start = time.clock()
    for j in range(len(array2)):
        array2[j] = array1[j] << 1
    total …

我现在正在学习Python,我正在努力理解容器在实践中的运作方式.有一个我无法解释的问题.假设,我创建了非常大的列表:

>>> l = [i for i in range(100000000)] # ~3 sec

创建它需要大约3秒钟(我使用升序数而不是相同的值来避免可能的优化)

我们可以在这里阅读,删除运营成本O(n).但是当我从列表中间删除一个元素时,它会立即返回(就像任何其他简单命令一样快,如元素访问)

>>> del l[50000000] # instantly (< 0.1 sec)

并在此之后我可以访问的元素l[25000000]和l[75000000]删除后在小于3秒,并且它也执行瞬间(所以,我无法通过延迟或背景去除解释这一点).

请有人解释一下,内部是如何完成的？该列表实际上是作为某种树实现的吗？这听起来很奇怪,而且,它会违反对恒定时间元素访问的要求.

它是一种常见的优化,比如C++中的返回值优化,还是一种罕见的,只针对我的平台/版本？

我使用Linux和Python 3.4.1(Python 2.7.9显示相同的结果).

我正在学习如何学习Python.

w = "This is the left side of..."
e = "a string with a right side."
print w + e

解释为什么添加两个字符串w和e+会产生更长的字符串.

即使我知道它可以工作,但我不明白为什么以及如何？请帮我.

我想让我的代码更有效(内存).现在我们有很多函数将iterable作为参数,如:

def foo(para,meter,iterable):
    #...
    pass

有时我们必须提供一个空列表来正常工作:foo(14,25,[]).问题是每次构造一个新列表时:它需要在堆上进行分配,并且列表似乎是64字节的内存(在我自己的机器上,经过测试sys.getsizeof([])),而空元组只需要一个(可能是一次) 48个字节.

因此我想知道空元组是否是一个常数.由于元组是不可变的,因此可以很容易地使元组的长度0(so ())在程序中保持不变.这会减少"构造时间"(因为它只会设置对常量的引用,所以没有)并减少分配的内存量.

我的问题是,对于Python解释器(即任何流行的解释器)是否有保证,空元组确实是一个常量,()因此不需要构造时间也不需要分配额外的内存.

测试它id(..)似乎支持这样的理论:确实只有一个零元组:

>>> id(())
140290183798856
>>> a = ()
>>> id(a)
140290183798856

但有可能在运行时Python解释器出于某种原因分叉元组.

当我执行以下步骤时,即使重新分配旧值(),两个元组(a和b)也都没有保留其原始ID (1,2).

>>> a , b = (1,2) , (1,2)
>>> a
(1, 2)
>>> b
(1, 2)
>>> id(a) , id(b)
(80131912, 91541064)
>>> a , b = (3,4) , (3,4)
>>> a
(3, 4)
>>> b
(3, 4)
>>> id(a) , id(b)
(91559048, 91689032)
>>> a , b = (1,2) , (1,2)
>>> a
(1, 2)
>>> b
(1, 2)
>>> id(a) , id(b)
(91556616, 91550408)

但是在下面的例子中,两者都得到了旧ID.

>>> a = (1,2)
>>> b …