python安装慢

Ⅰ 在阿里云上安装 python package 经常 timeout，有解决方案么

默认的pip有些确实比较慢，可以使用阿里云和豆瓣的镜像
pip install <package> -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com
pip install <package> -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

Ⅱ 联想旧笔记本win7x64位的操作系统为什么安装Python3.x版本的软件一直安装不上去，求解决

可以。联想Thinkpad R400这款PC机适合安装32位系统。如果用户想要选择64位操作系统，那就得考虑内存不够的问题了。 光盘安装win7系统的方法： 先下载win7系统的iso文件到本地硬盘； 准备一张空的DVD、CD光盘，然后刻录Win7（ios的文件格式）到你光盘上； 用大一点的U盘、移动硬盘把旧系统里面的重要文件备份；（如果全盘格式化，这一步忽略） 把刻录好的win7系统盘放入需要重新安装操作系统的光盘驱动器里并启动计算机； 启动过程中按del键进入BIOS设置CD-ROM引导，或者启动过程中按F12键直接选择CD-ROM启动； 出现Windows 7 安装界面，首先依次选择为中文（简体），中文（简体，中国），中文（简体）-美式键盘，选择好了点击下一步，然后点击“现在安装”； 安装程序启动过程中会出现安装协议，把接受许可条款的勾选中； 一直下一步，直到出现分区的界面，这里选择第一个分区，类型为系统，再点击下一步（再这之前可以格式的第一个分区，在驱动器选项（高级）（A）那里）； 分区完成以后等待一会，过一会提醒安装程序正在启动服务，再提醒重新启动您的计算机后安装过程将继续，这里是全自动的； 再次重新启动以后取出安装光盘，会自动检测用硬盘引导进入系统，这里出现正在启动Windows画面，安装程序正在检查视频性能，再看到让设置计算机名称这里输入PC名字（随便取个名字），在点击下一步，密码界面跳过，不要输入，紧接着画面转到输入密钥，如果是正版那就填写，如果不是，就不要填写，后期使用激活工具就可以了。 本地硬盘安装方法： 一般情况下，下载的都是ISO格式的镜像文件，将WIN7的安装包解压出来，用winrar、winzip、7Z、好压、软碟通等等都可以解压； 将这些文件复制到一个非系统盘的根目录下，系统盘大多数都是C盘，而根目录就是某个磁盘，比如F盘双击后进去的界面，一定不要放到文件夹里； 下面就需要一个软件来帮忙了，就是NT6HDD Installer（NT6 HDD Installer网络搜索下载安装这个软件），下载后放到之前存放win7安装文件的盘符的根目录，也就是和win7的安装文件放到一起然后运行，如果用户现在的系统是XP可以选择1，如果是vista或者win7选择2，选择后按回车开始安装，1秒钟左右结束，之后就是重启系统了； 在启动过程中会提示用户选择要启动的操作系统，这时选择新出来的nt6 hdd Installer mode 1选项； 下面就开始安装了：点击现在安装-选择我接受条款-选择自定义安装（第一个很慢很慢）-驱动器选项（高级）-如果想安装双系统，找个非系统的盘符安装，如果只想用WIN7，那就格式化之前的系统盘（之前一定要做好系统盘的备份）； 步骤5分区完成后，剩下的步骤都是常规的，按提示完成就可以了。

Ⅲ 菜鸟安装Python的几个小问题

在Windows上安装Python

首先，从Python的官方网站python.org下载最新的2.7版本，网速慢的同学请移步国内镜像。

然后，运行下载的MSI安装包，在选择安装组件的一步时，勾上所有的组件：

看到上面的画面，就说明Python安装成功！

Ⅳ 求助关于Python3.6 matplotlib的安装问题

下载超时，可能网速慢，也可能资源不好，多试几次，不行的话，直接复制如下的连接

pipinstall下载的whl文件

Ⅳ chemdraw里的python安装慢

默认的国外的资源。由于chemdraw里的python默认的国外的资源，下载国外资源的时候就需要翻墙，这样的话网速就会特别慢，有时候会出现没有网速就会timeout了。

Ⅵ python官网下载好慢

用迅雷下，浏览器的下载慢

Ⅶ 为啥我的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、pip、wine官网都在国外，受到互联网带宽的影响，下载速度是很慢。
但国内有镜像站点，常用软件都有，下载速度就很快了。
比如：阿里、清华、中国科技大学等镜像站，可以网上搜一下网址。