javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

为何对列表进行硬编码比计算速度慢?

我想将此序列的前1024个术语分配给一个列表。 我最初猜想,对列表进行硬编码将是最快的方法。 我还尝试通过算法生成列表,并发现它比硬编码要快。 因此,我测试了各种折衷方法,使用了越来越长的硬编码列表,并从算法上扩展到了1024个项目。 我发现最快的方法涉及对前128个项目进行硬编码并生成其余项目。

我想了解为什么硬编码序列中的前128个项目并计算其余部分比硬编码所有1024个项目要快。 使用Python 3.4.2 Shell(IDLE)和cProfile timeit(感谢Veedrac对改进的性能分析代码的回答)。 我将硬编码列表留在很长的一行上,以避免用数字行将问题弄乱,但除此之外,代码不需要水平滚动。

def hardcoded():
    m = [0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,9,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,10]

def softcoded():
    m = [0]
    for k in range(10):
        m += m
        m[-1] += 1

def hybrid():
    m = [0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7]
    for k in range(3):
        m += m
        m[-1] += 1

from timeit import Timer

def p_time(func, n=10000):
    print(func.__name__)
    print(min(Timer(func).repeat(10, n)) / n)

p_time(hardcoded)
p_time(softcoded)
p_time(hybrid)

时机

hardcoded
1.593102711162828e-05
softcoded
1.1183638458442147e-05
hybrid
9.69246251002005e-06

我将所有计时运行了几次,并粘贴到最低的位置。

trans by 2020-02-22T17:24:03Z

如何在Python中解析对变量的引用

该消息有很多示例,但是有点长,但是我希望将帮助我和其他人更好地掌握变量的全部内容和Python 2.7中的属性查找。

我正在使用PEP 227的条款([http://www.python.org/dev/peps/pep-0227/)]用于代码块(例如模块,类定义,函数定义等)和变量绑定(例如赋值,参数声明,类和函数声明,for循环等)

我将术语变量用于可以不使用点和需要用对象限定的名称的属性名称(例如obj.x作为对象obj的属性x)。

Python中所有代码块都有三个作用域,但有以下功能:

  • 本地
  • 全球
  • 内建

Python中有四个仅用于功能的块(根据(PEP 227):

  • 本地
  • 封闭功能
  • 全球
  • 内建

将变量绑定到块中并在其中查找的规则是非常简单:

  • 变量与块中对象的任何绑定都会使该变量局部变量,除非变量声明为全局变量(在该变量中变量属于全局范围)
  • 使用规则LGB(本地,全局的,内置的)所有块,但功能
  • 使用规则LEGB(本地,封闭的,全局的,内置的)。

让我知道一些验证此规则的示例,并展示了许多特别案例。 对于每个示例,我都会给出自己的理解。 请如果我错了,请纠正我。 对于最后一个示例,我不了解结果。

范例1:

x = "x in module"
class A():
    print "A: "  + x                    #x in module
    x = "x in class A"
    print locals()
    class B():
        print "B: " + x                 #x in module
        x = "x in class B"
        print locals()
        def f(self):
            print "f: " + x             #x in module
            self.x = "self.x in f"
            print x, self.x
            print locals()

>>>A.B().f()
A: x in module
{'x': 'x in class A', '__module__': '__main__'}
B: x in module
{'x': 'x in class B', '__module__': '__main__'}
f: x in module
x in module self.x in f
{'self': <__main__.B instance at 0x00000000026FC9C8>}

类(规则LGB)没有嵌套作用域,如果不使用,则类无法访问该类的属性限定名称(在此示例中为self.x)。 这在以下内容中有很好的描述PEP227。

范例2:

z = "z in module"
def f():
    z = "z in f()"
    class C():
        z = "z in C"
        def g(self):
            print z
            print C.z
    C().g()
f()
>>> 
z in f()
z in C

这里使用LEGB规则查找函数中的变量,但是如果路径中有一个类,则跳过类参数。 又是在这里,这就是PEP 227正在解释的内容。

范例3:

var = 0
def func():
    print var
    var = 1
>>> func()

Traceback (most recent call last):
  File "<pyshell#102>", line 1, in <module>
func()
  File "C:/Users/aa/Desktop/test2.py", line 25, in func
print var
UnboundLocalError: local variable 'var' referenced before assignment

我们期望使用诸如python这样的动态语言来处理一切动态解决。 但这不是函数的情况。 本地变量在编译时确定。 PEP 227和[http://docs.python.org/2.7/reference/executionmodel.html]描述了这一点这样的行为

“如果名称绑定操作发生在代码块内的任何地方,块中名称的使用被视为对当前块。”

示例4:

x = "x in module"
class A():
    print "A: " + x
    x = "x in A"
    print "A: " + x
    print locals()
    del x
    print locals()
    print "A: " + x
>>> 
A: x in module
A: x in A
{'x': 'x in A', '__module__': '__main__'}
{'__module__': '__main__'}
A: x in module

但是我们在这里看到,PEP227中的此声明“如果名称绑定该操作在代码块内的任何位置进行,使用该名称的所有方式该块中的内容被视为对当前块的引用。” is当代码块为类时出错。 而且,对于班级,似乎本地名称绑定不是在编译时进行的,而是在使用类名称空间执行。 在这方面,PEP227和Python文档中的执行模型具有误导性,并且有些零件错了。

范例5:

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            x = x
            print x
        return MyClass
    myfunc()
f2()
>>> 
x in module

我对这段代码的理解如下。 指令x = x首先查找表达式右手x所指的对象至。 在这种情况下,将在类中本地查找对象,然后遵循LGB规则,它将在全局范围内查找字符串“ x in module”。 然后,MyClass的局部属性x为在类字典中创建并指向字符串对象。

范例6:

现在这是一个我无法解释的例子。它与示例5非常接近,我只是在更改本地MyClass从x到y的属性。

x = 'x in module'
def  f2():
    x = 'x in f2'
    def myfunc():
        x = 'x in myfunc'
        class MyClass(object):
            y = x
            print y
        return MyClass
    myfunc()
f2()
>>>
x in myfunc

在这种情况下,为什么要在MyClass中查找x引用最内在的功能?

trans by 2020-02-14T07:57:09Z

python-为什么从列表创建列表会使它更大?

在应该相同的列表上使用sys.getsizeof时,我看到一些不一致之处。 (Python 2.7.5)

>>> lst = [0,1,2,3,4,5,6,7,8,9]
>>> sys.getsizeof(lst)
76
>>> lst2 = list(lst)
>>> sys.getsizeof(lst2)
104
>>> lst3 = list(lst2)
>>> sys.getsizeof(lst3)
104
>>> sys.getsizeof(lst[:])
76
>>> sys.getsizeof(lst2[:])
76

有人有一个简单的解释吗?

trans by 2020-02-07T12:56:17Z

Python字节码在CPython中到底如何运行?

我试图了解Python的工作原理(因为我一直都在使用它!)。 据我了解,当您运行python script.py之类的脚本时,该脚本将转换为字节码,然后解释器/ VM / CPython(实际上只是一个C程序)读取python字节码并相应地执行该程序。

该字节码如何读入? 它类似于在C语言中读取文本文件的方式吗? 我不确定Python代码如何转换为机器代码。 是否确实是Python解释器(CLI中的python命令)只是一个预编译的C程序,该程序已经转换为机器代码,然后将python字节码文件放入该程序中? 换句话说,我的Python程序是否从未真正转换为机器代码? python解释器已经存在于机器代码中了,所以我的脚本就不必了吗?

trans by 2020-02-06T14:49:38Z

python-为什么2 3 3的大小为36个字节,但是2 3 3的大小仅为24个字节?

Python中的所有内容都是一个对象。 因此,Python中int的大小将比平时大。

>>> sys.getsizeof(int())
24

可以,但是为什么int()还要多花12个字节,而不是long()而不是一个?

>>> sys.getsizeof(2**63)
36
>>> sys.getsizeof(2**62)
24

我得到int()是long类型,而long()是int类型,但是为什么要有12个字节的差异呢?

不再直观,我尝试了其他一些事情:

>>> a = 2**63
>>> a -= 2**62
>>> sys.getsizeof(a)
36

int()即使现在可以存储在int中,也仍然存储为long。 所以这并不奇怪。 但:

>>> a -= (2**63 - 1)
>>> a = 2**63
>>> a -= (2**63 - 1)
>>> a
1L
>>> sys.getsizeof(a)
28

新尺寸。

>>> a = 2**63
>>> a -= 2**63
>>> a
0L
>>> sys.getsizeof(a)
24

返回24字节,但仍然很长。

我得到的最后一件事:

>>> sys.getsizeof(long())
24

题:

在这些情况下,内存存储如何工作?

子问题:

为什么直觉告诉我们只有1位,所以要加上12个字节的间隙?

为什么int()long()为24个字节,但是long(1)已经为28个字节和int(2⁶²)

注意:Python 3.X的工作方式略有不同,但并不直观。 在这里,我专注于Python 2.7。 我没有在以前的版本上进行测试。

trans by 2020-01-22T10:57:08Z

len()关于集合和列表的复杂性

2712654058594294239488关于集合和列表的复杂度同样为O(1)。 为什么需要更多时间来处理集?

~$ python -m timeit "a=[1,2,3,4,5,6,7,8,9,10];len(a)"
10000000 loops, best of 3: 0.168 usec per loop
~$ python -m timeit "a={1,2,3,4,5,6,7,8,9,10};len(a)"
1000000 loops, best of 3: 0.375 usec per loop

它与特定的基准有关吗,例如,建立集合要比列表花费更多的时间,并且基准也将其考虑在内?

如果创建集合对象比创建列表花费更多的时间,那么潜在原因是什么?

trans by 2020-01-21T16:34:55Z

为什么range(0)== range(2,2,2)在Python 3中为true?

为什么在Python 3中用不同值初始化的范围彼此比较相等?

当我在解释器中执行以下命令时:

>>> r1 = range(0)
>>> r2 = range(2, 2, 2)
>>> r1 == r2
True

结果是True。为什么会这样? 为什么将具有不同参数值的两个不同的range对象视为相等?

trans by 2020-01-16T02:50:31Z

为什么variable1 + = variable2比variable1 = variable1 + variable2快得多?

我继承了一些Python代码,这些代码用于创建巨大的表(最多19列,每行5000行)。 花了九秒钟时间在屏幕上绘制了表格。 我注意到每一行都是使用以下代码添加的:

sTable = sTable + '\n' + GetRow()

其中sTable是字符串。

我将其更改为:

sTable += '\n' + GetRow()

我注意到桌子现在出现了六秒钟。

然后我将其更改为:

sTable += '\n%s' % GetRow()

基于这些Python性能提示(仍为6秒)。

由于调用了大约5000次,因此突出了性能问题。 但是为什么会有如此大的差异呢? 为什么编译器没有在第一个版本中发现问题并对其进行优化?

trans by 2020-01-13T19:55:52Z

改善Python中大型字典的性能

我发现如果在开始时初始化一个空字典,然后在for循环中向字典中添加元素(大约110,000个键,每个键的值是一个列表,并且在循环中也在增加),则速度会降低 循环。

我怀疑问题是,字典在初始化时不知道键的数量,并且它做的也不是很聪明,所以也许存储冲突变得很频繁并且变慢了。

如果我知道键的数量以及这些键的确切含义,那么python中有什么方法可以使字典(或哈希表)更有效地工作? 我隐约记得,如果您知道键,则可以巧妙地设计哈希函数(完美的哈希值?)并预先分配空间。

trans by 2020-01-09T21:45:50Z

python-“ from __future__ import大括号”代码在哪里?

我想知道在命令上执行的确切代码是什么:

>>> from __future__ import braces
SyntaxError: not a chance

因此,由于python是开源的,因此我打开了C:\Python27\Lib\__future__.py并进行了查找。令人惊讶的是,我在那里什么都没找到,无法处理导入braces模块。

因此,我的问题是,处理此问题的代码在哪里? 当我运行该命令时会发生什么?

trans by 2020-01-03T00:33:39Z

python-为什么string的startwith比in慢?

令人惊讶的是,我发现startswith__contains__慢:

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

众所周知,startswith操作需要搜索整个字符串,__contains__仅需要检查前几个字符,因此startswith应该更有效。

startswith足够大时,__contains__更快:

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

因此,调用startswith似乎有一些开销,这在字符串较小时会使速度变慢。

然后,我尝试找出startswith调用的开销是多少。

首先,我使用了startswith变量来减少点运算的成本-如此答案中所述-在这里我们可以看到__contains__仍然较慢:

In [16]: f=s.startswith

In [17]: %timeit f("XYZ")
1000000 loops, best of 3: 270 ns per loop

此外,我测试了空函数调用的成本:

In [18]: def func(a): pass

In [19]: %timeit func("XYZ")
10000000 loops, best of 3: 106 ns per loop

不管点操作和函数调用的成本如何,2699222347768529920的时间约为(270-106)= 164ns,但是__contains__操作仅花费81.7ns。 看来startswith仍有一些间接费用,那是什么?

根据poke和lvc的建议,将测试结果添加到startswith__contains__之间:

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

In [29]: %timeit s.__contains__("XYZ")
1000000 loops, best of 3: 192 ns per loop
trans by 2019-12-29T15:03:58Z

python-Set文字与set函数产生不同的结果

为什么set函数调用会清除重复项,但不能解析集合文字?

>>> x = Decimal('0')
>>> y = complex(0,0)
>>> set([0, x, y])
{0}
>>> {0, x, y}
{Decimal('0'), 0j}

(Python 2.7.12。可能与这个类似问题的根本原因相同)

trans by 2019-11-12T18:26:36Z

Python中的__weakref__到底是什么?

令人惊讶的是,没有__weakref__的明确文档。此处对弱引用进行了说明。 __slots__的文档中也简短提及__weakref__。但是我找不到有关__weakref__本身的任何信息。

__weakref__到底是什么?-它只是充当标志的成员:如果存在,则该对象可能被弱引用?-还是可以重写/分配以获得所需行为的函数/变量? 怎么样?

trans by 2019-11-04T23:50:05Z

为什么类__dict__是一个mappingproxy?

我想知道为什么__dict__类是mappingproxy,但是实例__dict__只是普通的dict

>>> class A:
...     pass

>>> a = A()
>>> type(a.__dict__)
<class 'dict'>
>>> type(A.__dict__)
<class 'mappingproxy'>
trans by 2019-10-23T22:28:36Z

为什么使用中间变量的代码要比不使用中间变量的代码快?

我遇到了这种奇怪的行为,但无法解释。 这些是基准:

py -3 -m timeit "tuple(range(2000)) == tuple(range(2000))"
10000 loops, best of 3: 97.7 usec per loop
py -3 -m timeit "a = tuple(range(2000));  b = tuple(range(2000)); a==b"
10000 loops, best of 3: 70.7 usec per loop

与使用变量分配进行比较,为什么比使用带有临时变量的班轮快27%以上呢?

根据Python文档,垃圾回收在timeit期间处于禁用状态,因此并非如此。 这是某种优化吗?

结果也可以在Python 2.x中复制,尽管程度较小。

运行Windows 7,CPython 3.5.1,Intel i7 3.40 GHz,64位OS和Python。 似乎我尝试使用Python 3.5.0在Intel i7 3.60 GHz上运行的另一台机器无法重现结果。


使用timeit.timeit() @ 10000循环使用相同的Python进程运行,分别产生了0.703和0.804。 仍然显示,尽管程度较小。(〜12.5%)

trans by 2019-09-22T21:29:53Z

python - 为什么复制洗牌列表要慢得多?

复制一个洗牌的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))
trans by 2019-08-28T19:07:30Z

python - 为什么max比sort更慢?

我发现max比Python 2和3中的sort功能要慢。

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

为什么maxO(n))比sort功能(O(nlogn))慢?

trans by 2019-08-12T05:39:45Z

python - 为什么元组(set([1,“a”,“b”,“c”,“z”,“f”]))== tuple(set([“a”,“b”,“c “,”z“,”f“,1]))85%的时间启用了哈希随机化?

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

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

在启用散列随机化的情况下,大约85%的时间打印True。 为什么85%?

trans by 2019-08-02T09:52:03Z

python - 为什么元组在内存中占用的空间少于列表?

list在Python中占用更少的内存空间:

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

lists需要更多的内存空间:

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

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

trans by 2019-08-01T18:32:25Z

查找内置Python函数的源代码?

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

trans by 2019-07-29T05:38:00Z

1 2 3 下一页 共3页