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官網都在國外，受到互聯網帶寬的影響，下載速度是很慢。
但國內有鏡像站點，常用軟體都有，下載速度就很快了。
比如：阿里、清華、中國科技大學等鏡像站，可以網上搜一下網址。