pythonenv
❶ 給系統盤留多少空間好python安裝在哪個盤好
給系統盤留50G-80G，python安裝在除C盤以外的任意盤都行。
系統盤50G即可，如果是固態可以不分區不過為了管理方便超過250G的建議分區安裝在哪裡都可以。現在python開發常用env環境，所需庫在哪裡都無所謂。若採用全局依賴安裝則需要找一個容量大的盤符。
相關資料
系統保留分區指的是Windows系統在第一次管理硬碟的時候，保留用於存放系統引導文件的分區。Windows Vista/7出於安全考慮，在新裝Windows 7（及以後的版本）過程中，如果利用光碟的分區工具給硬碟分區時，系統默認的將一部分（100-200M）的空間劃分出來。
不分配盤符（你在系統下看到的諸如C、D、E之類的字母），用於存放系統引導文件（電腦啟動時需要首先讀取的一部分具有特殊功能的文件）。
❷ 如何刪除python的虛擬環境
virtualenv 是一個創建隔絕的Python環境的工具。virtualenv創建一個包含所有必要的可執行文件的文件夾，用來使用Python工程所需的包。
安裝
pip install virtualenv
基本使用
為一個工程創建一個虛擬環境：
$ cd my_project_dir
$ virtualenv venv#venv為虛擬環境目錄名，目錄名自定義
virtualenv venv 將會在當前的目錄中創建一個文件夾，包含了Python可執行文件，以及 pip 庫的一份拷貝，這樣就能安裝其他包了。虛擬環境的名字（此例中是 venv ）可以是任意的；若省略名字將會把文件均放在當前目錄。
在任何你運行命令的目錄中，這會創建Python的拷貝，並將之放在叫做 venv 的文件中。
你可以選擇使用一個Python解釋器：
$ virtualenv -p /usr/bin/python2.7 venv# -p參數指定Python解釋器程序路徑
這將會使用 /usr/bin/python2.7 中的Python解釋器。
要開始使用虛擬環境，其需要被激活：
$ source venv/bin/activate
從現在起，任何你使用pip安裝的包將會放在 venv 文件夾中，與全局安裝的Python隔絕開。
像平常一樣安裝包，比如：
$ pip install requests
如果你在虛擬環境中暫時完成了工作，則可以停用它：
$ . venv/bin/deactivate
這將會回到系統默認的Python解釋器，包括已安裝的庫也會回到默認的。
要刪除一個虛擬環境，只需刪除它的文件夾。（執行 rm -rf venv ）。
這里virtualenv 有些不便，因為virtual的啟動、停止腳本都在特定文件夾，可能一段時間後，你可能會有很多個虛擬環境散落在系統各處，你可能忘記它們的名字或者位置。
virtualenvwrapper
鑒於virtualenv不便於對虛擬環境集中管理，所以推薦直接使用virtualenvwrapper。 virtualenvwrapper提供了一系列命令使得和虛擬環境工作變得便利。它把你所有的虛擬環境都放在一個地方。
安裝virtualenvwrapper(確保virtualenv已安裝)
pip install virtualenvwrapper
pip install virtualenvwrapper-win#Windows使用該命令
安裝完成後，在~/.bashrc寫入以下內容
export WORKON_HOME=~/Envs
source /usr/local/bin/virtualenvwrapper.sh
第一行：virtualenvwrapper存放虛擬環境目錄
第二行：virtrualenvwrapper會安裝到python的bin目錄下，所以該路徑是python安裝目錄下bin/virtualenvwrapper.sh
source ~/.bashrc#讀入配置文件，立即生效
virtualenvwrapper基本使用
1.創建虛擬環境mkvirtualenv
mkvirtualenv venv
這樣會在WORKON_HOME變數指定的目錄下新建名為venv的虛擬環境。
若想指定python版本，可通過"--python"指定python解釋器
mkvirtualenv --python=/usr/local/python3.5.3/bin/python venv
2. 基本命令
查看當前的虛擬環境目錄
[root@localhost ~]# workon
py2
py3
切換到虛擬環境
[root@localhost ~]# workon py3
(py3) [root@localhost ~]#
退出虛擬環境
(py3) [root@localhost ~]# deactivate
[root@localhost ~]#
刪除虛擬環境
rmvirtualenv venv
❸ python中怎麼用控制台使用方法
本文實例講述了Python顯示進度條的方法，是Python程序設計中非常實用的技巧。分享給大家供大家參考。具體方法如下：
首先，進度條和一般的print區別在哪裡呢？
答案就是print會輸出一個\n，也就是換行符，這樣游標移動到了下一行行首，接著輸出，之前已經通過stdout輸出的東西依舊保留，而且保證我們在下面看到最新的輸出結果。
進度條不然，我們必須再原地輸出才能保證他是一個進度條，否則換行了怎麼還叫進度條？
最簡單的辦法就是，再輸出完畢後，把游標移動到行首，繼續在那裡輸出更長的進度條即可實現，新的更長的進度條把舊的短覆蓋，就形成了動畫效果。
可以想到那個轉義符了吧，那就是\ r。
轉義符r就可以把游標移動到行首而不換行，轉義符n就把游標移動到行首並且換行。
在python中，輸出stdout(標准輸出)可以使用sys.stdout.write
例如：
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2
#Author: [email protected]
##2010-10-27 22:07
"""
Usage:
Just A Template
"""
from __future__ import division
import sys,time
j = '#'
if __name__ == '__main__':
for i in range(1,61):
j += '#'
sys.stdout.write(str(int((i/60)*100))+'% ||'+j+'->'+"\r")
sys.stdout.flush()
time.sleep(0.5)
print
第二種思路是用轉義符\b
轉義符\b是退格鍵，也就是說把輸出的游標往回退格子，這樣就可以不用+=了，例如：
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2
#Author: [email protected]
#2010-10-27 22:07
"""
Usage:
Just A Template
"""
from __future__ import division
import sys,time
if __name__ == '__main__':
for i in range(1,61):
sys.stdout.write('#'+'->'+"\b\b")
sys.stdout.flush()
time.sleep(0.5)
print
游標回退2格，寫個#再回退，再寫，達到增長的目的了
不過寫這么多似乎是廢話，在耳邊常常聽到一句話：那就是不要重復造輪子。實際上python有豐富發lib幫你實現這個東西，你完全可以把心思放在邏輯開發上而不用注意這些小細節
下面要介紹的就是這個類「progressbar」，使用easy_install可以方便的安裝這個類庫，其實就一個文件，拿過來放到文件同一個目錄下面也直接可以import過來
如下圖所示：
下面就是基本使用舉例：
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2
#Author: [email protected]
#2010-10-27 22:53
"""
Usage:
Just A Template
"""
from __future__ import division
import sys,time
from progressbar import *
total = 1000
#基本用法
progress = ProgressBar()
for i in progress(range(total)):
time.sleep(0.01)
pbar = ProgressBar().start()
for i in range(1,1000):
pbar.update(int((i/(total-1))*100))
time.sleep(0.01)
pbar.finish()
#高級用法
widgets = ['Progress: ', Percentage(), ' ', Bar(marker=RotatingMarker('>-=')),
' ', ETA(), ' ', FileTransferSpeed()]
pbar = ProgressBar(widgets=widgets, maxval=10000000).start()
for i in range(1000000):
# do something
pbar.update(10*i+1)
time.sleep(0.0001)
pbar.finish()
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
# coding:utf-8
import sys
import time
from progressbar import AnimatedMarker, Bar, BouncingBar, Counter, ETA, \
FileTransferSpeed, FormatLabel, Percentage, \
ProgressBar, ReverseBar, RotatingMarker, \
SimpleProgress, Timer
examples = []
def example(fn):
try:
name = 'Example %d' % int(fn.__name__[7:])
except:
name = fn.__name__
def wrapped():
try:
sys.stdout.write('Running: %s\n' % name)
fn()
sys.stdout.write('\n')
except KeyboardInterrupt:
sys.stdout.write('\nSkipping example.\n\n')
examples.append(wrapped)
return wrapped
@example
def example0():
pbar = ProgressBar(widgets=[Percentage(), Bar()], maxval=300).start()
for i in range(300):
time.sleep(0.01)
pbar.update(i + 1)
pbar.finish()
@example
def example1():
widgets = ['Test: ', Percentage(), ' ', Bar(marker=RotatingMarker()),
' ', ETA(), ' ', FileTransferSpeed()]
pbar = ProgressBar(widgets=widgets, maxval=10000000).start()
for i in range(1000000):
# do something
pbar.update(10 * i + 1)
pbar.finish()
@example
def example2():
class CrazyFileTransferSpeed(FileTransferSpeed):
"""It's bigger between 45 and 80 percent."""
def update(self, pbar):
if 45 < pbar.percentage() < 80:
return 'Bigger Now ' + FileTransferSpeed.update(self, pbar)
else:
return FileTransferSpeed.update(self, pbar)
widgets = [CrazyFileTransferSpeed(), ' <<<', Bar(), '>>> ',
Percentage(), ' ', ETA()]
pbar = ProgressBar(widgets=widgets, maxval=10000000)
# maybe do something
pbar.start()
for i in range(2000000):
# do something
pbar.update(5 * i + 1)
pbar.finish()
@example
def example3():
widgets = [Bar('>'), ' ', ETA(), ' ', ReverseBar('<')]
pbar = ProgressBar(widgets=widgets, maxval=10000000).start()
for i in range(1000000):
# do something
pbar.update(10 * i + 1)
pbar.finish()
@example
def example4():
widgets = ['Test: ', Percentage(), ' ',
Bar(marker='0', left='[', right=']'),
' ', ETA(), ' ', FileTransferSpeed()]
pbar = ProgressBar(widgets=widgets, maxval=500)
pbar.start()
for i in range(100, 500 + 1, 50):
time.sleep(0.2)
pbar.update(i)
pbar.finish()
@example
def example5():
pbar = ProgressBar(widgets=[SimpleProgress()], maxval=17).start()
for i in range(17):
time.sleep(0.2)
pbar.update(i + 1)
pbar.finish()
@example
def example6():
pbar = ProgressBar().start()
for i in range(100):
time.sleep(0.01)
pbar.update(i + 1)
pbar.finish()
@example
def example7():
pbar = ProgressBar() # Progressbar can guess maxval automatically.
for i in pbar(range(80)):
time.sleep(0.01)
@example
def example8():
pbar = ProgressBar(maxval=80) # Progressbar can't guess maxval.
for i in pbar((i for i in range(80))):
time.sleep(0.01)
@example
def example9():
pbar = ProgressBar(widgets=['Working: ', AnimatedMarker()])
for i in pbar((i for i in range(50))):
time.sleep(.08)
@example
def example10():
widgets = ['Processed: ', Counter(), ' lines (', Timer(), ')']
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(150))):
time.sleep(0.1)
@example
def example11():
widgets = [FormatLabel('Processed: %(value)d lines (in: %(elapsed)s)')]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(150))):
time.sleep(0.1)
@example
def example12():
widgets = ['Balloon: ', AnimatedMarker(markers='.oO<a href="">@*</a> ')]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(24))):
time.sleep(0.3)
@example
def example13():
# You may need python 3.x to see this correctly
try:
widgets = ['Arrows: ', AnimatedMarker(markers='←↖↑↗→↘↓↙')]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(24))):
time.sleep(0.3)
except UnicodeError:
sys.stdout.write('Unicode error: skipping example')
@example
def example14():
# You may need python 3.x to see this correctly
try:
widgets = ['Arrows: ', AnimatedMarker(markers='◢◣◤◥')]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(24))):
time.sleep(0.3)
except UnicodeError:
sys.stdout.write('Unicode error: skipping example')
@example
def example15():
# You may need python 3.x to see this correctly
try:
widgets = ['Wheels: ', AnimatedMarker(markers='◐◓◑◒')]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(24))):
time.sleep(0.3)
except UnicodeError:
sys.stdout.write('Unicode error: skipping example')
@example
def example16():
widgets = [FormatLabel('Bouncer: value %(value)d - '), BouncingBar()]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(180))):
time.sleep(0.05)
@example
def example17():
widgets = [FormatLabel('Animated Bouncer: value %(value)d - '),
BouncingBar(marker=RotatingMarker())]
pbar = ProgressBar(widgets=widgets)
for i in pbar((i for i in range(180))):
time.sleep(0.05)
@example
def example18():
widgets = [Percentage(),
' ', Bar(),
' ', ETA(),
' ', AdaptiveETA()]
pbar = ProgressBar(widgets=widgets, maxval=500)
pbar.start()
for i in range(500):
time.sleep(0.01 + (i < 100) * 0.01 + (i > 400) * 0.9)
pbar.update(i + 1)
pbar.finish()
@example
def example19():
pbar = ProgressBar()
for i in pbar([]):
pass
pbar.finish()
try:
for example in examples:
example()
except KeyboardInterrupt:
sys.stdout('\nQuitting examples.\n')
❹ python裝飾器是什麼意思
裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對於好多小白來講，這個功能 有點繞，自學時直接繞過去了，然後面試問到了就掛了，因為裝飾器是程序開發的基礎知識，這個都 不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。
1、先明白這段代碼
####第一波####
deffoo():
print'foo'
foo#表示是函數
foo()#表示執行foo函數
####第二波####
deffoo():
print'foo'
foo=lambdax:x+1
foo()#執行下面的lambda表達式，而不再是原來的foo函數，因為函數foo被重新定義了
2、需求來了
初創公司有N個業務部門，1個基礎平台部門，基礎平台負責提供底層的功能，如：資料庫操作、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平台提供的功能即可。如下：
###############基礎平台提供的功能如下###############
deff1():
print'f1'
deff2():
print'f2'
deff3():
print'f3'
deff4():
print'f4'
###############業務部門A調用基礎平台提供的功能###############
f1()
f2()
f3()
f4()
###############業務部門B調用基礎平台提供的功能###############
f1()
f2()
f3()
f4()
目前公司有條不紊的進行著，但是，以前基礎平台的開發人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平台的提供的功能可以被任何人使用。現在需要對基礎平台的所有功能進行重構，為平台提供的所有功能添加驗證機制，即：執行功能前，先進行驗證。
老大把工作交給 Low B，他是這么做的：
跟每個業務部門交涉，每個業務部門自己寫代碼，調用基礎平台的功能之前先驗證。誒，這樣一來基礎平台就不需要做任何修改了。
當天Low B 被開除了…
老大把工作交給 Low BB，他是這么做的：
###############基礎平台提供的功能如下###############
deff1():
#驗證1
#驗證2
#驗證3
print'f1'
deff2():
#驗證1
#驗證2
#驗證3
print'f2'
deff3():
#驗證1
#驗證2
#驗證3
print'f3'
deff4():
#驗證1
#驗證2
#驗證3
print'f4'
###############業務部門不變###############
###業務部門A調用基礎平台提供的功能###
f1()
f2()
f3()
f4()
###業務部門B調用基礎平台提供的功能###
f1()
f2()
f3()
f4()
過了一周 Low BB 被開除了…
老大把工作交給 Low BBB，他是這么做的：
只對基礎平台的代碼進行重構，其他業務部門無需做任何修改
###############基礎平台提供的功能如下###############
defcheck_login():
#驗證1
#驗證2
#驗證3
pass
deff1():
check_login()
print'f1'
deff2():
check_login()
print'f2'
deff3():
check_login()
print'f3'
deff4():
check_login()
print'f4'
老大看了下Low BBB 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：
老大說：
寫代碼要遵循開發封閉原則，雖然在這個原則是用的面向對象開發，但是也適用於函數式編程，簡單來說，它規定已經實現的功能代碼不允許被修改，但可以被擴展，即：
封閉：已實現的功能代碼塊
開放：對擴展開發
def w1(func): ==>將w1函數載入到內存
@w1
執行w1函數，並將 @w1 下面的函數作為w1函數的參數，即：@w1 等價於 w1(f1)
所以，內部就會去執行：
def inner:
#驗證
return f1() # func是參數，此時 func 等於 f1
return inner # 返回的 inner，inner代表的是函數，非執行函數
其實就是將原來的 f1 函數塞進另外一個函數中將執行完的 w1 函數返回值賦值給@w1下面的函數的函數名
w1函數的返回值是：
def inner:
#驗證
return 原來f1() # 此處的 f1 表示原來的f1函數
然後，將此返回值再重新賦值給 f1，即：
新f1 =def inner:
#驗證
return 原來f1()
所以，以後業務部門想要執行 f1 函數時，就會執行 新f1 函數，在 新f1 函數內部先執行驗證，再執行原來的f1函數，然後將 原來f1 函數的返回值 返回給了業務調用者。
如此一來， 即執行了驗證的功能，又執行了原來f1函數的內容，並將原f1函數返回值 返回給業務調用著
如果將開放封閉原則應用在上述需求中，那麼就不允許在函數 f1 、f2、f3、f4的內部進行修改代碼，老闆就給了Low BBB一個實現方案：
defw1(func):
definner():
#驗證1
#驗證2
#驗證3
returnfunc()
returninner
@w1
deff1():
print'f1'
@w1
deff2():
print'f2'
@w1
deff3():
print'f3'
@w1
deff4():
print'f4'
對於上述代碼，也是僅僅對基礎平台的代碼進行修改，就可以實現在其他人調用函數 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。
Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什麼呢？
老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：
單獨以f1為例：
defw1(func):
definner():
#驗證1
#驗證2
#驗證3
returnfunc()
returninner
@w1
deff1():
print'f1'
當寫完這段代碼後（函數未被執行、未被執行、未被執行），python解釋器就會從上到下解釋代碼，步驟如下：
沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數在沒有被調用之前其內部代碼不會被執行。
從表面上看解釋器著實會執行這兩句，但是 @w1 這一句代碼里卻有大文章，@函數名是python的一種語法糖。
如上例@w1內部會執行一下操作：
Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！
先把上述流程看懂，之後還會繼續更新…
3、問答時間
問題：被裝飾的函數如果有參數呢？
#一個參數
defw1(func):
definner(arg):
#驗證1
#驗證2
#驗證3
returnfunc(arg)
returninner
@w1
deff1(arg):
print'f1'
#兩個參數
defw1(func):
definner(arg1,arg2):
#驗證1
#驗證2
#驗證3
returnfunc(arg1,arg2)
returninner
@w1
deff1(arg1,arg2):
print'f1'
#三個參數
defw1(func):
definner(arg1,arg2,arg3):
#驗證1
#驗證2
#驗證3
returnfunc(arg1,arg2,arg3)
returninner
@w1
deff1(arg1,arg2,arg3):
print'f1'
問題：可以裝飾具有處理n個參數的函數的裝飾器？
defw1(func):
definner(*args,**kwargs):
#驗證1
#驗證2
#驗證3
returnfunc(*args,**kwargs)
returninner
@w1
deff1(arg1,arg2,arg3):
print'f1'
問題：一個函數可以被多個裝飾器裝飾嗎？
defw1(func):
definner(*args,**kwargs):
#驗證1
#驗證2
#驗證3
returnfunc(*args,**kwargs)
returninner
defw2(func):
definner(*args,**kwargs):
#驗證1
#驗證2
#驗證3
returnfunc(*args,**kwargs)
returninner
@w1
@w2
deff1(arg1,arg2,arg3):
print'f1'
問題：還有什麼更吊的裝飾器嗎？
#!/usr/bin/envpython
#coding:utf-8
defBefore(request,kargs):
print'before'
defAfter(request,kargs):
print'after'
defFilter(before_func,after_func):
defouter(main_func):
defwrapper(request,kargs):
before_result=before_func(request,kargs)
if(before_result!=None):
returnbefore_result;
main_result=main_func(request,kargs)
if(main_result!=None):
returnmain_result;
after_result=after_func(request,kargs)
if(after_result!=None):
returnafter_result;
returnwrapper
returnouter
@Filter(Before,After)
defIndex(request,kargs):
print'index'
❺ python的基本語法是什麼
語法規則，條件語句、循環語句、方法、類那些。基本內數據類型，Python是弱類型需要容，但還是有類型的，這些類型的特點及操作。內置庫API的使用，比如sqlite、網路請求庫、json等。
Python由荷蘭數學和計算機科學研究學會的Guido van Rossum於1990 年代初設計，作為一門叫做ABC語言的替代品。
Python提供了高效的高級數據結構，還能簡單有效地面向對象編程。Python語法和動態類型，以及解釋型語言的本質，使它成為多數平台上寫腳本和快速開發應用的編程語言，隨著版本的不斷更新和語言新功能的添加，逐漸被用於獨立的、大型項目的開發。
Python解釋器易於擴展，可以使用C或C++（或者其他可以通過C調用的語言）擴展新的功能和數據類型。 Python 也可用於可定製化軟體中的擴展程序語言。Python豐富的標准庫，提供了適用於各個主要系統平台的源碼或機器碼。
2021年10月，語言流行指數的編譯器Tiobe將Python加冕為最受歡迎的編程語言，20年來首次將其置於Java、C和JavaScript之上。
❻ 如何運行Python程序的方法
1.
使用Python自帶的IDLE
在開始-->程序-->Python2.5(視你安裝的版本而不同)中找到IDLE(Python
GUI)，
點擊後彈出如下窗體:
在>>>提示符後輸入代碼，回車，就可以執行此代碼。
IDLE支持語法高亮，支持自動縮進，支持方法提示，不過提示的很慢。
2.
在命令行窗口上運行
這種方法的前提是:你在系統的PATH變數中配置了Python的安裝路徑。
右鍵我的電腦-->屬性-->高級-->環境變數，在系統變數列表中找到Path項，點擊編輯按鈕，在其中追加「C:\Python25;」(路徑及版本視你安裝而定)，保存退出。
開始-->運行-->輸入cmd，回車，開啟一個CMD窗口。
在DOS提示符>後，輸入python，回車，進入Python環境。
它的運行和IDLE基本一致，但是沒有了語法高亮、自動縮進、方法提示，唯一的好處就是運行速度比IDLE快了些(如果你告訴我可以加參數運行python，那你就不算新手了，也不用看這篇文章了)，所以用處不大。
退出此python環境使用Ctrl
+
Z，然後回車。
3.
以腳本方式運行
以上兩種運行方式雖然簡便，但是不適合大量代碼的開發，只適合查看單句或少量幾句代碼的運行結果，或者驗證某函數的調用方法，而這恰恰是我們平時調試、驗證程序的常用方式。如果是正式的開發，則應該使用獨立腳本的方式運行。
打開你的文本編輯器(我是用EmEditor，當然你使用記事本、寫字板也都可以)，輸入python代碼，保存成*.py文件，然後雙擊運行它就可以執行了，當然前提也是必須配置系統PATH變數。
l
在其所在目錄下開啟一個CMD窗口，輸入python
*.py運行
l
在代碼的最後增加如下語句:
raw_input()
然後你再雙擊運行，結果就會停留在那裡，直到你敲擊回車鍵才消失。
linux下運行Python程序，一般說來有以下兩種形式，其實和Windows下基本一樣。
一、在IDLE中運行
在終端窗口輸入$
python進入互動式運行環境，然後就可以邊輸入邊執行代碼了:
>>>
print
'Hello
Python'
Hello
Python>>>退出使用Ctrl-D。
二、以腳本方式運行
在py腳本所在目錄下輸入
❼ #!/usr/bin/env python與#!/usr/bin/python的區別
在unix類的操作系統才有意義。
#!/usr/bin/python是告訴操作系統執行這個腳本的時候，調用/usr/bin下的python解釋器。
#!/usr/bin/env python這種用法是為了防止操作系統用戶沒有將python裝在默認的/usr/bin路徑里。當系統看到這一行的時候，首先會到env設置里查找python的安裝路徑，再調用對應路徑下的解釋器程序完成操作。
(7)pythonenv擴展閱讀：
Python是一種計算機程序設計語言。是一種動態的、面向對象的腳本語言，最初被設計用於編寫自動化腳本(shell)，隨著版本的不斷更新和語言新功能的添加，越來越多被用於獨立的、大型項目的開發。
Python常用的代碼：,
1，生成隨機數
rnd=random.randint(1,500)：生成1-500之間的隨機數
2，讀文件
f=open("c:\1.txt","r")
lines=f.readlines()
forlineinlines
printline
3，寫文件
f=open("c:\1.txt","r+")：可讀可寫模式
f.write("123")：寫入字元串
4正則表達式，讀取tomcat的日誌並列印日期
importre
regx="dddd-dd-d+"
f=open("c:stdout.log","r")
i=0
forstrinf.readlines():
ifre.search(regx,str):
Response.write(str+"<br>")
ifi>10:break
i=i+1
f.close();
5,連接資料庫
importpgdb
conn=pgdb.connect
(host='localhost',databse='qingfeng',user='qingfeng',password='123')
cur=conn.cursor()
cur.execute("select * from dream")
printcur.rowcount
❽ 如何刪除python的虛擬環境
rmvirtualenv venv
virtualenv是一個創建隔絕的Python環境的工具。virtualenv創建一個包含所有必要的可執行文件的文件夾，用來使用Python工程所需的包。
安裝
pip install virtualenv
基本使用
為一個工程創建一個虛擬環境：
- $ cd my_project_dir
- $ virtualenv venv#venv為虛擬環境目錄名，目錄名自定義
- $ virtualenv -p /usr/bin/python2.7 venv# -p參數指定Python解釋器程序路徑
要開始使用虛擬環境，其需要被激活：
- $ source venv/bin/activate
- $ pip install requests
如果你在虛擬環境中暫時完成了工作，則可以停用它：
- $ . venv/bin/deactivate
- pip install virtualenvwrapper
- pip install virtualenvwrapper-win#Windows使用該命令
- export WORKON_HOME=~/Envs
- source /usr/local/bin/virtualenvwrapper.sh
- source ~/.bashrc#讀入配置文件，立即生效
- mkvirtualenv venv
- mkvirtualenv --python=/usr/local/python3.5.3/bin/python venv
- [root@localhost ~]# workon
- py2
- py3
- [root@localhost ~]# workon py3
- (py3) [root@localhost ~]#
- (py3) [root@localhost ~]# deactivate
- [root@localhost ~]#
- rmvirtualenv venv
virtualenvvenv將會在當前的目錄中創建一個文件夾，包含了Python可執行文件，以及pip庫的一份拷貝，這樣就能安裝其他包了。虛擬環境的名字（此例中是venv）可以是任意的；若省略名字將會把文件均放在當前目錄。
在任何你運行命令的目錄中，這會創建Python的拷貝，並將之放在叫做venv的文件中。
你可以選擇使用一個Python解釋器：
這將會使用/usr/bin/python2.7中的Python解釋器。
從現在起，任何你使用pip安裝的包將會放在venv文件夾中，與全局安裝的Python隔絕開。
像平常一樣安裝包，比如：
這將會回到系統默認的Python解釋器，包括已安裝的庫也會回到默認的。
要刪除一個虛擬環境，只需刪除它的文件夾。（執行rm-rfvenv）。
這里virtualenv 有些不便，因為virtual的啟動、停止腳本都在特定文件夾，可能一段時間後，你可能會有很多個虛擬環境散落在系統各處，你可能忘記它們的名字或者位置。
virtualenvwrapper
鑒於virtualenv不便於對虛擬環境集中管理，所以推薦直接使用virtualenvwrapper。virtualenvwrapper提供了一系列命令使得和虛擬環境工作變得便利。它把你所有的虛擬環境都放在一個地方。
安裝virtualenvwrapper(確保virtualenv已安裝)
安裝完成後，在~/.bashrc寫入以下內容
第一行：virtualenvwrapper存放虛擬環境目錄
第二行：virtrualenvwrapper會安裝到python的bin目錄下，所以該路徑是python安裝目錄下bin/virtualenvwrapper.sh
virtualenvwrapper基本使用
1.創建虛擬環境mkvirtualenv
這樣會在WORKON_HOME變數指定的目錄下新建名為venv的虛擬環境。
若想指定python版本，可通過"--python"指定python解釋器
2. 基本命令
查看當前的虛擬環境目錄
切換到虛擬環境
退出虛擬環境
刪除虛擬環境
❾ python基礎語法知識詢問
由於Python語言的簡潔、易讀以及可擴展性，在國外用Python做科學計算的研究機構日益增多，一些知名大學已經採用Python教導學生程序設計的首選編程語言。例如麻省理工學院的計算機科學及編程導論課程就使用Python語言講授。
想必大家還想了解到更多知識技能，接下來就跟千鋒武漢Python培訓的老師就來分享一下Python基礎語法的四大知識點，希望大家會喜歡。
一、標識符
a)概念：對變數，常量，函數，類等對象起的名字。嚴格區分大小寫。
b)標識符命名規則：
語法要求(硬性)：
i.必須以字母或者下劃線開頭(支持中文，中文也是字元)
ii.必須以字母，數字，下劃線組成
iii.區分大小寫
iv.不能和關鍵字和內置函數名同名。
代碼規范(彈性)：
v.變數名全部小寫，常量全部大寫(代碼規范，不是語法要求)
vi.類名用大寫駝峰(代碼規范)、
vii.模塊和包名用小寫
二、關鍵字
a)Import keyword keyword.kwlist 查看所有關鍵字
三、注釋
a)單行：#開頭
b)多行：每行使用#
c)文檔注釋：使用三個引號包括起來(」」」 XXX 「」」),這種注釋專門為函數或者類形成說明文檔。注釋必須跟在定義體下面，不能再任意位置。
四、代碼頭兩行
a)#!/usr/bin/env Python:指定運行代碼的解釋器，linux專用，windows不需要。在linux下添加改行，則可以使用./xxx.py執行。如果使用Python xxx.py則不需要改行。
b)# -*- coding:utf-8 -*- ：代碼的編碼方式
❿ Windows環境下安裝第2個Python（不同版本）
系統已經安裝的3.10，現在需要安裝另一個3.9版本的Python。
安裝目錄不同於現有已安裝Python版本的目錄
找到安裝目錄的兩個exe文件：
C:.exe
C:w.exe
將其改名為：
C:39.exe
C:w39.exe
添加python3.9.12安裝目錄：
C:yaoinstallPythonPython39
C:
創建虛擬環境
進入虛擬環境文件夾，執行activate.bat
C:.bat
查看python版本，使用python和python39都可以查看。
這里有點暈，為什麼python和python39兩者都可以運行呢？
退出虛擬環境方法：
python3.9安裝成功，昨天基於python3.10無法安裝。