Python的缺点是什么？[关闭]

如今，Python似乎风行一时，而且并非不值得-因为它确实是一种语言，几乎有人喜欢用它来解决新问题。但是，正如一个智者曾经说过的（称他为智者，仅是因为我不知道是谁说的；不知道他是否真的是那个智者），真正懂一门语言的人不仅会知道它的语言，语法，设计等优点，但也有缺点。没有一种语言是完美的，有些只是比其他更好。

因此，您认为Python的客观缺点是什么。

注意：我不是在这里要求进行语言比较（即C＃比Python更好，因为... yadda yadda yadda）-客观（某种程度上）认为哪些语言功能设计不当，是否，可能是什么？一些您在其中缺少的东西，依此类推。如果必须使用另一种语言作为比较，而仅仅是为了说明一个要点，否则很难对此进行详细说明（即，为了易于理解）

我经常使用Python，总的来说，我认为它是一种非常好的语言。但是，没有一种语言是完美的。以下这些缺点对我个人很重要：

1. 太慢了 我的意思是真的，真的很慢。很多时候这并不重要，但这绝对意味着您需要另一种语言来处理那些对性能至关重要的位。

2. 嵌套函数有点烂，因为您不能在外部范围内修改变量。 编辑： 由于支持库，我仍然使用Python 2，这个设计缺陷使我烦恼不已，但是由于非本地语句，显然它已在Python 3中修复。等不及要移植我使用的库，以便可以将该缺陷永久发送到历史的灰堆中。

3. 它缺少一些可能对库/通用代码有用的功能，恕我直言，将其简单化为不健康的极端情况。我能想到的最重要的是用户定义的值类型（我猜它们可以用元类魔术创建，但我从未尝试过）和ref函数参数。

4. 它离金属很远。需要编写线程原语或内核代码之类的东西吗？祝好运。

5. 尽管我不介意缺乏预先捕获语义错误的能力来权衡Python提供的动态性，但我希望有一种方法可以捕获语法错误和愚蠢的事情，例如错误地混淆变量名，而不必实际运行代码。

6. 该文档不如具有强大的公司支持的PHP和Java语言那样好。

我讨厌Python无法区分变量的声明和用法。您无需进行静态输入即可实现这一目标。最好有一种方式说“这是我故意声明的变量，我打算引入一个新名称，这不是错字”。

此外，我通常以一次写入样式使用Python变量，也就是说，我将变量视为不可变的，并且在第一次分配变量后不对其进行修改。由于有了列表理解等功能，这实际上非常容易，并且使代码流更易于遵循。

但是，我无法证明这一事实。Python中没有什么阻止我覆盖或重用变量。

总之，我想用该语言有两个关键字：var和let。如果我写入未由任何一个声明的变量，Python应该引发错误。此外，将let变量声明为只读，而var变量为“普通”。

考虑以下示例：

x = 42    # Error: Variable `x` undeclared

var x = 1 # OK: Declares `x` and assigns a value.
x = 42    # OK: `x` is declared and mutable.

var x = 2 # Error: Redeclaration of existing variable `x`

let y     # Error: Declaration of read-only variable `y` without value
let y = 5 # OK: Declares `y` as read-only and assigns a value.

y = 23    # Error: Variable `y` is read-only

请注意，类型仍然是隐式的（但是let对于所有意图和目的，变量都是静态类型的，因为它们不能反弹到新值，而var变量仍可以动态类型）。

最后，所有方法参数应自动​​为let，即它们应为只读。除了以下习惯用法外，通常没有充分的理由来修改参数：

def foo(bar = None):
    if bar == None: bar = [1, 2, 3]

可以用稍微不同的惯用语代替：

def foo(bar = None):
    let mybar = bar or [1, 2, 3]

我主要抱怨的是线程，由于全局解释器的锁定，线程在许多情况下（与Java，C和其他语言相比）表现不佳（请参阅“ Inside the Python GIL”（PDF链接））。

但是，有一个多进程接口非常易于使用，但是对于相同数量的进程vs.线程，它将占用更多的内存，如果共享数据很多，则很难。但是，好处是，一旦您的程序可以处理多个进程，它就可以在多台计算机上扩展，而线程化程序则无法做到。

我对文档的批判确实不同意，我认为它是出色的，并且比大多数（如果不是全部）主要语言都更好。

另外，您还可以捕获运行pylint的许多运行时错误。

可以说，缺少静态类型会导致某些类型的运行时错误，这不值得鸭子类型提供的增加的灵活性。

我认为Python的面向对象的部分有点“被烙印”。您可以说，将“自我”显式传递给每个方法的全部需求是一个症状，即它的OOP组件没有明确计划。它还显示了Python有时谨慎的作用域规则，该规则在另一个答案中遭到批评。

编辑：

当我说Python的面向对象部分感到“笨拙”时，我的意思是有时OOP方面会感到相当不一致。以Ruby为例：在Ruby中，一切都是对象，您使用熟悉的obj.method语法调用方法（当然，重载的运算符除外）；在Python中，一切也都是对象，但是有些方法是作为函数调用的；即，您重载__len__以返回长度，但是使用len(obj)而不是obj.length其他语言中更常见（更一致）的长度来调用它。我知道此设计决定背后有一些原因，但我不喜欢它们。

此外，Python的OOP模型缺乏任何类型的数据保护，即不会有私有，保护和公共成员; 你可以模仿他们使用_，并__在方法前面，但它是一种丑陋。

我不喜欢Python的事情：

1. 线程化（我知道它已经被提及，但值得在每篇文章中提及）。
2. 不支持多行匿名函数（lambda只能包含一个表达式）。
3. 缺少一个简单但强大输入读取功能/类（像的cin或scanf在C ++和C或ScannerJava中）。
4. 默认情况下，所有字符串都不是unicode（但在Python 3中已修复）。

具有可变数据类型的默认参数。

def foo(a, L = []):
    L.append(a)
    print L

>>> foo(1)
[1]
>>> foo(2)
[1, 2]

通常是一些细微错误的结果。我认为最好在需要默认参数的情况下创建一个新的列表对象（而不是创建用于每个函数调用的单个对象）。

编辑：这不是一个大问题，但是当需要在文档中引用某些内容时，通常意味着这是一个问题。这不是必需的。

def foo(a, L = None):
    if L is None:
        L = []
    ...

特别是当它应该是默认值时。这只是一种奇怪的行为，与您的预期不符，并且在很多情况下都没有用。

Python的某些功能使其灵活地成为一种开发语言，对于那些使用诸如C ++和Java之类的编译和链接过程进行的“整个程序”静态分析所使用的功能，也将其视为主要缺点。

• 隐式声明局部变量

使用普通赋值语句声明局部变量。这意味着任何其他作用域中的变量绑定都需要编译器进行显式注释（外部作用域的全局和非本地声明，实例作用域的属性访问标记）。这极大地减少了编程时所需的样板数量，但是这意味着需要第三方静态分析工具（例如pyflakes）来执行由编译器以需要显式变量声明的语言处理的检查。

• 支持“猴子修补”

模块，类对象甚至内置命名空间的内容都可以在运行时进行修改。这是非常强大的功能，允许使用许多非常有用的技术。但是，这种灵活性意味着Python不提供静态类型的OO语言所共有的某些功能。最值得注意的是，实例方法的“ self”参数是显式的，而不是隐式的（因为不必在类内部定义“方法”，因此可以在以后通过修改类来添加它们，这意味着它不是特别实用）隐式地传递实例引用），并且根据代码是在类的“内部”还是“外部”（因为该区别仅在执行类定义时存在），就不能轻易实施属性访问控制。

• 远离金属

许多其他高级语言也是如此，但是Python倾向于抽象掉大多数硬件细节。像C和C ++这样的系统编程语言仍然更适合于处理直接的硬件访问（但是，Python将非常高兴地通过CPython扩展模块，或者更可移植地通过ctypes库与之对话）。

1. 对代码块使用缩进，而不要使用{} / begin-end。
2. 每种较新的现代语言都有适当的词法作用域，但Python没有（见下文）。
3. 混乱的文档（与Perl5文档相比，非常好）。
4. 海峡夹克（只有一种方法可以做到）。

范围界定破例；口译会议的笔录：

>>> x=0
>>> def f():
...     x+=3
...     print x
... 
>>> f()
Traceback (most recent call last):
  File "", line 1, in ?
  File "", line 2, in f
UnboundLocalError: local variable 'x' referenced before assignment

global并nonlocal引入了关键字来弥补这种设计上的愚蠢。

我发现python的面向对象this.method()和过程/功能method(this)语法的组合非常令人不安：

x = [0, 1, 2, 3, 4]
x.count(1)
len(x)
any(x)
x.reverse()
reversed(x)
x.sort()
sorted(x)

这特别糟糕，因为大量函数（而不是方法）只是转储到全局名称空间中：与列表，字符串，数字，构造函数，元编程相关的方法，全部混合在一个大的按字母顺序排序的列表中。

至少，像F＃这样的功能语言在模块中正确命名了所有函数：

List.map(x)
List.reversed(x)
List.any(x)

所以他们并不在一起。此外，这是整个库遵循的标准，因此至少是一致的。

我了解执行功能与方法的事情的原因，但是我仍然认为将它们像这样混合起来是一个坏主意。如果遵循方法语法，至少对于常见操作，我会更加高兴：

x.count(1)
x.len()
x.any()
x.reverse()
x.reversed()
x.sort()
x.sorted()

无论方法是否在变异，将它们作为对象上的方法都具有以下优点：

• 在单个位置查找数据类型上的“常见”操作：其他库/等。可能还有其他对数据类型可以做的事情，但是“默认”操作全部在对象的方法中。
• Module调用时无需继续重复Module.method(x)。以上面的功能列表示例为例，为什么我必须List一遍又一遍地说？它应该知道它是一个List，我不想在上面调用该Navigation.map()函数！使用x.map()语法可使它保持DRY且仍然清晰。

当然，它比通用名称空间中的所有方法都具有优势。并不是说当前的方法无法完成任务。它甚至很简洁（len(lst)），因为没有命名空间！我了解使用函数（默认行为等）优于方法的优势，但我仍然不喜欢它。

太乱了 在大型项目中，混乱是您最大的敌人。

缺乏同质性。

Python必须等待3.x添加“ with”关键字。在任何谐音语言中，它都可以轻松地添加到库中。

我在答案中看到的大多数其他问题是以下三种类型之一：

1）可以通过工具修复的事物（例如pyflakes）2）实施细节（GIL，性能）3）可以通过编码标准修复的事物（即人们不希望使用的功能）

＃2并不是语言问题，IMO＃1和＃3并不是严重问题。

Python是我最喜欢的语言，因为它具有很高的表达力，但仍然可以避免您犯太多错误。我还有一些让我烦恼的事情：

• 没有真正的匿名功能。Lambda可用于单语句功能，该with语句可用于在Ruby中使用代码块的许多事情。但是在某些情况下，它会使事情变得比实际情况更加笨拙。（远没有Java那样笨拙，但仍然...）

• 模块和文件之间的关系有些混乱。从命令行运行“ python foo.py”与“ import foo”不同。Python 2.x中的相对导入也会引起问题。尽管如此，Python的模块仍然比C，C ++和Ruby的相应功能好得多。

• 明确的self。即使我了解其中的某些原因，并且即使我每天都使用Python，但我还是会犯忘记它的错误。与此相关的另一个问题是，从模块中制作一个类变得有些乏味。显性的自我与他人抱怨的范围有限有关。Python中最小的作用域是函数作用域。如果您按照自己的意愿将函数缩小，那么这本身就不是问题，而且IMO通常会提供更简洁的代码。

• len您希望某些全局函数（例如）是一种方法（它实际上是在幕后）。

• 重大缩进。不是这个想法本身，我认为很棒，但是由于这是使许多人无法尝试Python的唯一原因，因此也许可以使用一些（可选）开始/结束符号来使Python更好。忽略那些人，我也完全可以适应缩进的尺寸。

• 它不是Web浏览器的内置语言，而是JavaScript。

在这些投诉中，我只是非常关注我认为应该添加到语言中的第一个投诉。除了最后一个以外，其他的都比较小，如果发生的话会很棒！

Python尚未完全成熟：此时的python 3.2语言与当前分发的大多数软件包都存在兼容性问题（通常它们与python 2.5兼容）。这是一个很大的缺点，当前需要更多的开发工作（查找所需的软件包；验证兼容性；权衡选择一个可能不太兼容的不太好的软件包；采用最佳版本，将其更新为3.2，这可能需要几天的时间；然后开始做一些有用的事情）。

可能在2012年中期，这将成为一个弊端。

请注意，我想我被一个狂热的男孩所鄙视。在开发人员讨论中，我们的高级开发人员团队得出了相同的结论。

从一个主要意义上讲，成熟度意味着团队可以使用该技术并非常快速地启动和运行，而没有隐患（包括兼容性问题）。如今，大多数第三方软件包的第3方python软件包和许多应用程序都无法在3.2下运行。这将导致更多的集成，测试，重新实现技术本身的工作，而不是解决眼前的问题==不太成熟的技术。

2013年6月更新：Python 3仍然存在成熟度问题。团队成员经常会提及所需的软件包，然后说“除了仅适用于2.6”（在某些情况下，我已经通过localhost套接字实现了变通方法，以将仅2.6的软件包与2.6一起使用，其余的我们的工具仅适用于3.2）。甚至纯Python Wiki MoinMoin都不是用Python 3编写的。

Python的作用域已严重破坏，这使得Python中的面向对象编程非常尴尬。

我对Python的看法：

• 固定的OOP（有关此问题的详细说明，请参见@mipadi的答案）
• lambdas的执行失败
• 范围问题
• 标准库中没有持久性集合
• 对嵌入式DSL的适应性差

Python中的访问修饰符不是强制性的-使其很难编写结构良好的模块化代码。

我想这是@Mason破坏范围的一部分-这种语言通常存在很大的问题。对于本来应该可读的代码，似乎很难确定在什么范围内可以和应该在什么范围内以及在任何给定时间点的值-由于这些缺点，我目前正在考虑从Python语言继续前进。

仅仅因为“我们都同意成年人”并不意味着我们不会犯错并且不能在一个强大的结构中更好地工作，尤其是在处理复杂的项目时-缩进和无意义的下划线似乎并不足够。

1. 效果不佳，但是随着pypy的提高，
2. GIL阻止使用线程加速代码（尽管这通常是过早的优化），
3. 它仅对应用程序编程有用，

但是它具有一些很棒的兑换功能：

1. 非常适合RAD
2. 与C的接口很容易（并且C可以嵌入python解释器），
3. 可读性很强
4. 很容易学习
5. 有据可查
6. 电池确实包含在内，它的标准库很大，而pypi包含了几乎所有模块，
7. 它拥有一个健康的社区。

我确实喜欢python，我想到的第一个缺点是在注释一条语句时，例如，if myTest():您必须更改整个执行块的缩进，而不必使用C或Java。实际上，在python中，而不是注释掉if子句，我开始用这种方式注释掉它：`if True：#myTest（）这样，我也不必更改以下代码块。由于Java和C不依赖缩进，因此使用C和Java可以更轻松地注释掉语句。

多重调度不能与已建立的单调度类型系统很好地集成，并且性能也不高。

在并行文件系统上，动态加载是一个巨大的问题，在此类文件系统中，类似POSIX的语义导致元数据密集型操作的灾难性减速。我的同事花了25万个核心小时的时间才将Python（带有numpy，mpi4py，petsc4py和其他扩展模块）加载到65k内核上。（该模拟提供了重要的新科学成果，因此值得这样做。但是，当燃烧一桶以上的油来装载Python时，这是一个问题。）无法静态链接迫使我们不得不做出巨大的扭曲来获取合理的大规模加载时间，包括修补libc-rtld以dlopen执行集体文件系统访问。

• 相当广泛的一堆非常主流的第三方库和软件不是pythonic。一些示例：soaplib，openerp，reportlab。Critique不在范围之内，它在那儿被广泛使用，但是它使python文化混乱了（这打击了座右铭：“应该有一种-最好只有一种-显而易见的方式”）。已知的pythonic成功（例如django或trac）似乎是例外。
• 实例，类，元类的潜在无限抽象深度在概念上是美丽而独特的。但是要掌握它，您必须深刻了解解释器（解释python代码的顺序等）。它并没有广为人知和使用（或正确使用），而类似的黑魔法（例如C＃泛型）在概念上更令人费解（IMHO）似乎按比例更广为人知和使用。
• 要掌握内存和线程模型，您必须对python有一定的经验，因为这里没有全面的规范。您只知道有效的方法，可能是因为您阅读了口译员的资料或经验丰富的怪癖，并发现了解决方法。例如，只有强引用或弱引用，而不是Java的软引用和幻象引用。Java有一个用于垃圾回收的线程，而对于何时在python中进行垃圾回收却没有正式的答案。您可以观察到，如果不执行任何python代码，则不会发生垃圾回收，并得出结论，在尝试分配内存时有时可能会发生垃圾回收。当您不知道为什么不释放锁定的资源时可能会很棘手（我的经验是freeswitch中的mod_python）。

无论如何，python是我四年来的主要语言。成为狂热分子，精英主义者或狂人并不是蟒蛇文化的一部分。

• 奇怪的OOP：
  • len(s) 通过 __len__(self)和其他“特殊方法”
  • 可以从其他特殊方法（__add__以及__iadd__for +和+=）派生而来的特殊方法
  • self 作为第一个方法参数
  • 您可以忘记调用基类构造函数
  • 没有访问修饰符（私有，受保护的...）
• 没有常量定义
• 自定义类型没有不变性
• 吉尔
• 糟糕的性能导致Python和C的混合使用以及构建问题（寻找C库，平台依赖项...）
• 错误的文档，尤其是在第三方库中
• Python 2.x和3.x之间不兼容
• 不良的代码分析工具（与Java或C＃等静态类型的语言提供的工具相比）

“不可变性”并不是它的强项。AFAIK数字，元组和字符串是不可变的，其他所有内容（即对象）都是可变的。将其与功能语言（如Erlang或Haskell）进行比较，后者一切都是不可变的（至少默认情况下是不可变的）。

但是，不可变性确实通过并发*闪耀，这也不是Python的强项，因此至少是必然的。

（* =对于nitpickers：我的意思是，并发至少部分是并行的。我猜想Python可以使用“单线程”并发，在这种情况下，不变性并不那么重要。（是的，喜欢FP的人，我知道不变性是即使没有并发也很棒。））

我很想拥有明确的并行结构。当我写一个列表理解像

[ f(x) for x in lots_of_sx ]

我不在乎元素的处理顺序。有时，我什至不在乎它们的返回顺序。

即使我的f是纯Python时CPython不能很好地做到这一点，也可以将此类行为定义为供其他实现使用。

Python没有尾调用优化，主要是出于哲学原因。这意味着在大型结构上进行尾递归可能会占用O（n）内存（由于保留了不必要的堆栈），并且需要您将递归重写为循环以获取O（1）内存。