标签: cpython

在我看来,我遇到了这种奇怪的行为:

"a b c".split(maxsplit=1)
TypeError: split() takes no keyword arguments

为什么str.split()不接受关键字参数,即使它有意义？我在Python2和Python3中都发现了这种行为.

参考以下链接:http://docs.python.org/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe

我想知道以下内容:

(x, y) = (y, x)

将在cPython中保证原子.(x和y都是python变量)

由于dictPython 3.6 中的实现发生了变化,现在默认排序.现在还set保留秩序吗？

我找不到任何关于它的信息,但由于这两种数据结构在它们工作的方式非常相似,我认为可能就是这种情况.

我知道dict在所有情况下都无法订购s,但它们大多数情况下都是如此.如Python文档中所述:

这个新实现的顺序保留方面被认为是一个实现细节,不应该依赖它

我正在玩sys' getsizeof(),发现False(或0)包含的字节数少于True(或1).这是为什么？

import sys

print("Zero: " + str(sys.getsizeof(0)))
print("One: " + str(sys.getsizeof(1)))
print("False: " + str(sys.getsizeof(False)))
print("True: " + str(sys.getsizeof(True)))

# Prints:
# Zero: 24
# One: 28
# False: 24
# True: 28

实际上,其他数字(也包括一个以上的数字)是28个字节.

for n in range(0, 12):
  print(str(n) + ": " + str(sys.getsizeof(n)))

# Prints:
# 0: 24
# 1: 28
# 2: 28
# 3: 28
# 4: 28
# 5: 28
# 6: 28 …

我最近惊讶地发现，虽然 dicts 保证在 Python 3.7+ 中保留插入顺序，但集合不是：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> d['d'] = 4
>>> d
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> s = {'a', 'b', 'c'}
>>> s
{'b', 'a', 'c'}
>>> s.add('d')
>>> s
{'d', 'b', 'a', 'c'}

这种差异的基本原理是什么？导致 Python 团队更改 dict 实现的相同效率改进也不适用于集合吗？

我不是在寻找指向有序集实现的指针或使用 dicts 作为集合的替代品的方法。我只是想知道为什么 Python 团队没有在他们为 dicts 这样做的同时使内置集保留顺序。

是否有合理的标准和跨平台方式将文本(甚至PS/PDF)打印到系统定义的打印机？

假设这里有CPython,而不是像使用Jython和Java打印API那样聪明.

Python 2.7.2 (default, Jun 12 2011, 14:24:46) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> None > 0
False
>>> None == 0
False
>>> None < 0
True

• 是None使用为内置类型定义的算术运算符(在本例中为整数)进行比较？
• 是语言规范的前两个和第三个比较部分之间的区别(Python的规范 - 你一定是开玩笑:) :)或者它是CPython的实现细节？

看看这个:

>>> def f():
...     return (2+3)*4
... 
>>> dis(f)
  2           0 LOAD_CONST               5 (20)
              3 RETURN_VALUE  

显然,编译器已预先评估(2+3)*4,这是有道理的.

现在,如果我只是改变操作数的顺序*:

>>> def f():
...     return 4*(2+3)
... 
>>> dis(f)
  2           0 LOAD_CONST               1 (4)
              3 LOAD_CONST               4 (5)
              6 BINARY_MULTIPLY     
              7 RETURN_VALUE  

表达式不再完全预先评估!这是什么原因？我正在使用CPython 2.7.3.

我正在考虑in运营商如何实施

>>> s1 = 'abcdef'
>>> s2 = 'bcd'
>>> s2 in s1
True

在CPython中,哪个算法用于实现字符串匹配,以及时间复杂度是多少？有关于此的官方文件或维基吗？

当通过解包参数调用函数时,它似乎会增加两次递归深度.我想知道为什么会这样.

一般:

depth = 0

def f():
    global depth
    depth += 1
    f()

try:
    f()
except RuntimeError:
    print(depth)

#>>> 999

通过拆包电话:

depth = 0

def f():
    global depth
    depth += 1
    f(*())

try:
    f()
except RuntimeError:
    print(depth)

#>>> 500

理论上两者都应达到1000左右:

import sys
sys.getrecursionlimit()
#>>> 1000

这发生在CPython 2.7和CPython 3.3上.

在PyPy 2.7和PyPy 3.3上存在差异,但它要小得多(1480 vs 1395和1526 vs 1395).

从反汇编中可以看出,除了调用类型(CALL_FUNCTIONvs CALL_FUNCTION_VAR)之外,两者之间几乎没有区别:

import dis

def f():
    f()

dis.dis(f)
#>>>  34           0 LOAD_GLOBAL              0 (f)
#>>>               3 CALL_FUNCTION            0 (0 positional, …