① 为啥我的python这么慢
Pythn是动态类型而不是静态类型的，这意味着，在程序执行时，解释器并不知道变量的类型。对C语言来说，编译器在声明变量的时候就知道其类型了；对Python来说，程序执行时只知道一个变量是某种Python对象。
对于下面的C代码
int a = 1;
int b = 2;
int c = a + b;
编译器始终知道a和b是整型，在执行相加运算时，流程如下:
把<int> 1赋值给a
把<int> 2赋值给b
调用binary_add<int, int>(a, b)
把结果赋值给c
实现同样功能的Python代码如下
a = 1
b = 2
c = a + b
解释器只知道1和2是对象，但是并不知道这个对象的类型。所以解释器必须检查每个变量的PyObject_HEAD才能知道变量类型，然后执行对应的相加操作，最后要创建一个新的Python对象来保存返回值，大致流程如下：
把1赋值给a
设置a->PyObject_HEAD->typecode为整型
设置a->val = 1
把2赋值给b
设置a->PyObject_HEAD->typecode为整型
设置b->val = 2
调用binary_add<int, int>(a, b)
a->PyObject_HEAD获取类型编码
a是一个整型；值为a->val
b->PyObject_HEAD获取类型编码
b是一个整型，值为b->val
调用binary_add<int, int>(a->val, b->val)
结果为整型，存在result中
创建对象c
设c->PyObject_HEAD->typecode为整型
设置c->val为result
动态类型意味着任何操作都会涉及更多的步骤。这是Python对数值操作比C语言慢的主要原因
Python是解释型语言
上面介绍了解释型代码和编译型代码的一个区别。智能的编译器可以提前预见并优化重复或不需要的操作，这会带来性能的提升。编译器是一个大的话题，这里不会展开。
Python的对象模型会带来低效的内存访问
和C语言的整数对比时，我们指出了Python多了额外一层信息。现在来看看数组的情况。在Python中我们可以使用标准库中提供的List对象；而在C语言中我们会使用基于缓冲区的数组。
最简单的NumPy数组是围绕C数据构建的Python对象，也就是说它有一个指向连续数据缓存区的指针。而Python的list具有指向连续的指针缓冲区的指针，这些指针每个都指向一个Python对象，结合上面的例子，这些Python对象是一个整数对象。这个结构像下面这样
很容易看出，如果你正在执行按顺序逐步完成数据的操作，numpy的内存布局比Python的内存布局更为高效，无论是存储成本还是访问的时间成本。
为什么使用Python
鉴于Python天生的低效率，我们为什么还要使用Python呢？种种理由大致可以归结为：动态类型使得Python比C更容易使用。Python非常的灵活和宽容，这种灵活性可以有效地利用开发时间，并且在那些确实需要C和Fortran优化的场合，Python可以轻松链接到已编译的库中。这也是Python在科学社区的使用率不断增长的原因。经提到了一些结论性的东西，下面我们用Python的一些工具来做一些验证。
下面的实验使用到了python, ipython, numpy，版本信息如下：
python:3.6.5
1.13.3
In [1]: import sys
In [2]: import numpy
In [3]: sys.version[:5]
Out[3]: '3.6.5'
In [4]: numpy.__version__
Out[4]: '1.13.3'
本次实验使用机器64位的机器，如果是32位的机器话，下面提到的一些struct可能会有所不同。
整数
Python的整数使用起来非常简单。
In [5]: x = 42
In [6]: print(x)
42
接口的简单性掩盖了底层的复杂。在之前的内容里有提到过Python整数的内存布局。现在我们使用Python内置的ctypes模块来自省整数类型，前提是需要知道在C API中Python整数类型的定义。
在CPython中，变量x存储在一个名为_longobject的struct中，源码见Include/longintrepr.h
struct _longobject {
PyObject_VAR_HEAD
digit ob_digit[1];
}
其中PyObject_VAR_HEAD是一个宏，在Include/object.h中定义的结构如下
typedef struct {
PyObject ob_base;
Py_ssize_t ob_size;
} PyVarObject;
其中PyObject在Include/object.h中定义如下
typedef struct _object {
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
}
其中_PyObject_HEAD_EXTRA是一个在Python版本中通常不使用的宏。
将上面的信息结合起来，可以得到下面的结构
struct _longobject {
long ob_refcnt;
PyTypeObject *ob_type;
size_t ob_size;
long ob_digit[1];
}
这里面ob_refcnt变量是对象的引用计数，ob_type是指向包含该对象所有类型信息和方法定义的结构的指针，ob_digit保存实际的数值。
有了上面的知识，可以开始使用ctypes模块来观察时间的对象结构并提取上面的信息。
现在来用Python定义一个C的struct
In [7]: import ctypes
In [9]: class IntStruct(ctypes.Structure):
...: _fields_ = [
...: ("ob_refcnt", ctypes.c_long),
...: ("ob_type", ctypes.c_void_p),
...: ("ob_size", ctypes.c_ulong),
...: ("ob_digit", ctypes.c_long)
...: ]
...:
...: def __repr__(self):
...: return (
...: "IntStruct(ob_digit)={self.ob_digit}, refcount={self.ob_refcnt}"
...: ).format(self=self)
...:
现在用42来做实验。在Python中，id方法会返回对象的内存地址：
In [10]: num = 42
In [11]: IntStruct.from_address(id(42))
Out[11]: IntStruct(ob_digit)=42, refcount=61
可以看到ob_digit指向了内存中的正确位置。但是这里只创建了一个对象，为什么引用次数是61呢？
事实证明，这是一个性能优化，Python使用了很多小的整数，如果为每一个数字都创建一个PyObject，会消耗掉不少内存。出于这个考虑，Python将一些常用的数字做了单例实现，这样每个数字在内存中只有一份拷贝。换句话说，如果在这个范围内创建一个新的Python整数时，只是创建了一个对该数值对象的引用。
In [16]: x = 42
In [17]: y = 42
In [18]: id(x) == id(y)
Out[18]: True
上面的例子中，x和y都指向了同一个内存地址。在使用更大的数的时候，等式就不成立了
In [19]: x = 1234
In [20]: y = 1234
In [21]: id(x) == id(y)
Out[21]: False
Python解释器启动时候会创建很多的整数对象；可以看看这些对象的引用分布
%matplotlib osx
import matplotlib.pyplot as plt
import sys
plt.loglog(range(1000), [sys.getrefcount(i) for i in range(1000)])
plt.xlabel('integer value')
plt.ylabel('reference count')
Out[8]: Text(0,0.5,'reference count')
可以看到0被引用了数千次，一般情况下，引用的频率随着整数值的增加而减少。
再来看看ob_digit对应的值
In [8]: all(i == IntStruct.from_address(id(i)).ob_digit for i in range(256))
Out[8]: True
如果更细心一点，就可以发现，对于大于256的值，ob_digit就不能对应到正确的值了：在Objects/longobject.c中对数值有一些移位操作，这也是Python对一些大整数的处理方式。
比如
In [11]: 2 ** 100
Out[11]:
这个值显然是超过了long类型的范围了。
List类型
现在来看看一个更复杂的数据类型：List。同样能在Include/listobject.h中找到List类型的struct结构：
typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;
和之前一样，得到有效的结构体如下：
typedef struct {
long ob_refcnt;
PyTypeObject *ob_type;
Py_ssize_t ob_size;
PyObject **ob_item;
long allocated;
} PyListObject;
其中PyObject **ob_item指向list的数据，ob_size指出list中数据的个数。
In [3]: class ListStruct(ctypes.Structure):
...: _fields_ = [("ob_refcnt", ctypes.c_long),
...: ("ob_type", ctypes.c_void_p),
...: ("ob_size", ctypes.c_ulong),
...: ("ob_item", ctypes.c_long), # PyObject** pointer cast t
...: o long
...: ("allocated", ctypes.c_ulong)]
...:
...: def __repr__(self):
...: return ("ListStruct(len={self.ob_size}, "
...: "refcount={self.ob_refcnt})").format(self=self)
试验一下
In [8]: L = [1, 2, 3, 4]
In [9]: ListStruct.from_address(id(L))
Out[9]: ListStruct(len=4, refcount=1)
为确保得到的结果是正确的，对这个list增加几个引用，看看会不会影响引用计数：
In [10]: tup = [L, L]
In [11]: ListStruct.from_address(id(L))
Out[11]: ListStruct(len=4, refcount=3)
使用ctypes可以创建由之前IntStruct对象组成的复合结构
In [20]: Lstruct = ListStruct.from_address(id(L))
In [21]: PtrArray = Lstruct.ob_size * ctypes.POINTER(IntStruct)
In [22]: L_values = PtrArray.from_address(Lstruct.ob_item)
看看每个元素的值
In [23]: [ptr[0] for ptr in L_values]
Out[23]:
[IntStruct(ob_digit=1, refcount=4705),
IntStruct(ob_digit=2, refcount=1102),
IntStruct(ob_digit=3, refcount=559),
IntStruct(ob_digit=4, refcount=726)]
NumPy的数组
同样的，我们来看看numpy中的数组。其C-API定义的结构见numpy/core/include/numpy/ndarraytypes.h，这里用的numpy版本是1.13.3，不同版本的结构可能有所不同。
In [25]: np.__version__
Out[25]: '1.13.3'
现在用ctypes来创建一个numpy数组的结构吧。
In [31]: class NumpyStruct(ctypes.Structure):
...: _fields_ = [("ob_refcnt", ctypes.c_long),
...: ("ob_type", ctypes.c_void_p),
...: ("ob_data", ctypes.c_long), # char* pointer cast to long
...: ("ob_ndim", ctypes.c_int),
...: ("ob_shape", ctypes.c_voidp),
...: ("ob_strides", ctypes.c_voidp)]
...:
...: @property
...: def shape(self):
...: return tuple((self.ob_ndim * ctypes.c_int64).from_address(self.ob_shape))
...:
...: @property
...: def strides(self):
...: return tuple((self.ob_ndim * ctypes.c_int64).from_address(self.ob_strides))
...:
...: def __repr__(self):
...: return ("NumpyStruct(shape={self.shape}, "
...: "refcount={self.ob_refcnt})").format(self=self)
新建一个numpy数组试试In [32]: x = np.random.random((10, 20)) In [33]: xstruct = NumpyStruct.from_address(id(x)) In [34]: xstruct Out[34]: NumpyStruct(shape=(10, 20), refcount=1)
可以看到已经拿到了正确的shape。现在看看引用计数的情况
In [35]: L = [x, x, x]
In [36]: xstruct
Out[36]: NumpyStruct(shape=(10, 20), refcount=4)
现在可以看看里面的数据了。
In [37]: x = np.arange(10)
In [38]: xstruct = NumpyStruct.from_address(id(x))
In [39]: size = np.prod(xstruct.shape)
In [40]: arraytype = size * ctypes.c_long
In [41]: data = arraytype.from_address(xstruct.ob_data)
In [42]: [d for d in data]
Out[42]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
上面的data变量存储了Numpy数组中定义的连续的内存块，可以改一下其中的值。
In [43]: x[4] = 555
In [44]: [d for d in data]
Out[44]: [0, 1, 2, 3, 555, 5, 6, 7, 8, 9]
上面的例子可以证明x和data指向了同一块连续内存。
比较Python的list和numpy的ndarray的内部结构，明显可以看出numpy的数据对于表示同类型的数据列表来说简单的多。
结语
Python很慢，正如上面所说，一个重要原因是类型的间接寻址，这也是Python对开发者友好的原因。同时，Python本身也提供了可用于破解Python对象的工具，通过使用这些工具可以解析CPython的一些内部行为。
上
② 终端运行Python过慢啊
PYTHON确实是要慢一点，不知道你环境怎样，19秒也太慢了，我的老破电脑三五秒能响应。
小程序我一般用PERL，速度飞快。
③ 为什么我的cmd调用python特别慢，大概有十几秒时间
直接用鼠标点python.exe运行怎么样呢
是不是环境变量太多太多了导致电脑寻找命令过慢
配置怎么样噢
④ python运行速度慢怎么办
yxhtest7772017-07-18
关注
分享
697 2
python运行速度慢怎么办？6个Python性能优化技巧
Python是一门非常酷的语言，因为很少的Python代码可以在短时间内做很多事情，并且，Python很容易就能支持多任务和多重处理。
Python的批评者声称Python性能低效、执行缓慢，但实际上并非如此：尝试以下6个小技巧，可以加快Python应用程序。
关键代码可以依赖于扩展包
Python使许多编程任务变得简单，但是对于很关键的任务并不总是提供最好的性能。使用C、C++或者机器语言扩展包来执行关键任务能极大改善性能。这些包是依赖于平台的，也就是说，你必须使用特定的、与你使用的平台相关的包。简而言之,该解决方案提供了一些应用程序的可移植性,以换取性能,您可以获得只有通过直接向底层主机编程。
下面这些扩展包你可以考虑添加到你的个人扩展库中：
Cython
PyInlne
PyPy
Pyrex
这些包有不同的作用和执行方式。例如，Pyrex 让Python处理一些内存任务变得简单高效；PyInline可以直接让你在Python应用程序中使用C代码，虽然内联代码被单独编译，但是如果你能高效的利用C代码，它可以在同一个地方处理每一件事情。
使用关键字排序
有很多古老的Python代码在执行时将花费额外的时间去创建一个自定义的排序函数。最好的排序方式是使用关键字和默认的sort()方法。
优化循环
每一种编程语言都强调循环语句的优化，Python也是一样的。尽管你可以依赖于丰富的技术让循环运行的更快，然而，开发者经常忽略的一个方法是避免在循环内部使用点拼接字符串。
使用新版本
任何一个在线上搜索Python资料的人都会发现无数关于Python版本迁移的信息。通常，Python每一个版本都针对之前的一个版本做了优化和改进，以让Python运行的更快。限制因素是你喜欢的函数库是否也针对Python的新版本做了改进。
当你使用了新的函数库，获得了Python的新版本，你需要保证代码依然能够运行，检查应用，修正差异。然后，如果你仅仅是
⑤ Python 执行速度慢只是因为它是解释型语言吗
Python 不是解释型语言，事实上也没有“解释型”语言这个分类。
Python 性能略有不佳的原因可能有几个：
首先是 Python 希望自己是一个简单和优雅的语言，需要性能的组件通常用 C 实现，没有太多改进性能的动力。
然后 Python 具有垃圾回收和自动的内存管理功能，并且采用动态类型系统，会在运行时进行类型检查，这会不可避免地略微影响性能，使其不如静态类型(Java)或没有垃圾回收(C/C++)的语言。
摘自维基网络：
“Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。”
“因为Python属于动态类型语言，动态类型语言是在运行期间检查数据的类型，不得不保持描述变量值的实际类型标记，程序在每次操作变量时，需要执行数据依赖分支”
⑥ 为什么python多线程这么慢
差不多是这样子。多线程目前仅用于网络多线程采集， 以及性能测试。
其它的语言也有类似的情况，线程本身的特点导致线程的适用范围是受限的。只有CPU过剩，而其它的任务很慢，此时用线程才是有益的，可以很好平衡等待时间，提高并发性能。
线程的问题主要是线程的安全稳定性。线程无法强制中止，同时线程与主进程共享内存，可能会影响主进程的内存管理。
在python里线程出问题，可能会导致主进程崩溃。 虽然python里的线程是操作系统的真实线程。
那么怎么解决呢？通过我们用进程方式。子进程崩溃后，会完全的释放所有的内存和错误状态。所以进程更安全。 另外通过进程，python可以很好的绕过GIL，这个全局锁问题。
但是进程也是有局限的。不要建立超过CPU总核数的进程，否则效率也不高。
简单的总结一下。
当我们想实现多任务处理时，首先要想到使用multiprocessing， 但是如果觉着进程太笨重，那么就要考虑使用线程。 如果多任务处理中需要处理的太多了，可以考虑多进程，每个进程再采用多线程。如果还处理不要，就要使用轮询模式，比如使用poll event, twisted等方式。如果是GUI方式，则要通过事件机制，或者是消息机制处理，GUI使用单线程。
所以在python里线程不要盲目用， 也不要滥用。 但是线程不安全是事实。如果仅仅是做几个后台任务，则可以考虑使用守护线程做。如果需要做一些危险操作，可能会崩溃的，就用子进程去做。 如果需要高度稳定性，同时并发数又不高的服务。则强烈建议用多进程的multiprocessing模块实现。
在linux或者是unix里，进程的使用代价没有windows高。还是可以接受的。
⑦ python程序每次运行开始都比较慢
pycharm本来就是一个庞大的软件，因为功能强大，用很方便，所以运行起来才慢，可以用来做大项目，
python自带的idle就是一个轻量级的小工具，但是初学或做些小东西足够了
⑧ 请问大佬们，为什么我python运行程序特别慢啊，我这个程序怎么改一下可以运行的更快呢
您好，茫茫人海之中，能为君排忧解难实属朕的荣幸，在下拙见，若有错误，还望见谅！。展开全部
yxhtest7772017-07-18
关注
分享
697 2
python运行速度慢怎么办？6个Python性能优化技巧
Python是一门非常酷的语言，因为很少的Python代码可以在短时间内做很多事情，并且，Python很容易就能支持多任务和多重处理。
Python的批评者声称Python性能低效、执行缓慢，但实际上并非如此：尝试以下6个小技巧，可以加快Python应用程序。
关键代码可以依赖于扩展包
Python使许多编程任务变得简单，但是对于很关键的任务并不总是提供最好的性能。使用C、C++或者机器语言扩展包来执行关键任务能极大改善性能。这些包是依赖于平台的，也就是说，你必须使用特定的、与你使用的平台相关的包。简而言之,该解决方案提供了一些应用程序的可移植性,以换取性能,您可以获得只有通过直接向底层主机编程。
下面这些扩展包你可以考虑添加到你的个人扩展库中：
Cython
PyInlne
PyPy
Pyrex
这些包有不同的作用和执行方式。例如，Pyrex 让Python处理一些内存任务变得简单高效；PyInline可以直接让你在Python应用程序中使用C代码，虽然内联代码被单独编译，但是如果你能高效的利用C代码，它可以在同一个地方处理每一件事情。
使用关键字排序
有很多古老的Python代码在执行时将花费额外的时间去创建一个自定义的排序函数。最好的排序方式是使用关键字和默认的sort()方法。
优化循环
每一种编程语言都强调循环语句的优化，Python也是一样的。尽管你可以依赖于丰富的技术让循环运行的更快，然而，开发者经常忽略的一个方法是避免在循环内部使用点拼接字符串。
使用新版本
任何一个在线上搜索Python资料的人都会发现无数关于Python版本迁移的信息。通常，Python每一个版本都针对之前的一个版本做了优化和改进，以让Python运行的更快。限制因素是你喜欢的函数库是否也针对Python的新版本做了改进。
当你使用了新的函数库，获得了Python的新版本，你需要保证代码依然能够运行，检查应用，修正差异。然后，如果你仅仅是非常感谢您的耐心观看，如有帮助请采纳，祝生活愉快！谢谢！
⑨ 为什么说Python运行慢
越高级的需要封装的东西越多，用起来简单，但是运行起来考虑了很多东西。他的库是通用性的，运行起来就慢。
⑩ 使用python编程处理大量数据，效率太慢怎么解决
既然存有上千万个数据，为什么不使用数据库呢？
使用小型的sqlite数据库，加上适当的索引、筛选，肯定能大大提高数据处理速度。
python也自身带有处理sqlite数据库的模块，极其方便。