python怎麼實現
Ⅰ 想用python編寫一個腳本,登錄網頁,在網頁里做一系列操作,應該怎樣實現
python編寫一個腳本的具體操作：
1、首先，打開python並創建一個新的PY文件。
Ⅱ python怎麼實現一個進程
想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。
開辟子進程
multiprocessing中提供了Process類來生成進程實例
Process([group [, target [, name [, args [, kwargs]]]]])1
group分組，實際上不使用
target表示調用對象，你可以傳入方法的名字
args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可
kwargs表示調用對象的字典
name是別名，相當於給這個進程取一個名字
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #獲取當前進程號和正在運行是的時間
- time.sleep(wTime) #等待（休眠）
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,)) #申請子進程
- p.start() #運行進程
- print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())12345678910111213141516171819
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(wTime)
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,))
- p.daemon = True #加入daemon
- p.start() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(wTime)
- n += 1if __name__ == "__main__":
- p = Process(target=run_proc, args=(2,))
- p.daemon = True
- p.start()
- p.join() #加入join方法
- print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())21
- # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):
- def __init__(self, wTime):
- Process.__init__(self)
- self.wTime = wTime def run(self):
- n = 0
- while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
- time.sleep(self.wTime)
- n += 1if __name__ == "__main__":
- p = Myprocess(2)
- p.daemon = True
- p.start() #自動調用run方法
- p.join() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())2122232425262728
- # -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name): ##定義一個函數用於進程調用
- for i in range(5):
- time.sleep(0.2) #休眠0.2秒
- print 'Run child process %s (%s)' % (name, os.getpid())#執行一次該函數共需1秒的時間if __name__ =='__main__': #執行主進程
- print 'Run the main process (%s).' % (os.getpid())
- mainStart = time.time() #記錄主進程開始的時間
- p = Pool(8) #開辟進程池
- for i in range(16): #開辟14個進程
- p.apply_async(run_proc,args=('Process'+str(i),))#每個進程都調用run_proc函數，
- #args表示給該函數傳遞的參數。
- print 'Waiting for all subprocesses done ...'
- p.close() #關閉進程池
- p.join() #等待開辟的所有進程執行完後，主進程才繼續往下執行
- print 'All subprocesses done'
- mainEnd = time.time() #記錄主進程結束時間
- print 'All process ran %0.2f seconds.' % (mainEnd-mainStart) #主進程執行時間21222324
先來個小例子：
運行結果：
Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017
根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。
通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。
有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。
執行結果：
Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017
這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼
執行結果：
subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017
這樣所有的進程就能順利的執行了。
將進程定義成類
通過繼承Process類，來自定義進程類，實現run方法。實例p通過調用p.start()時自動調用run方法。
如下：
執行結果和上一個例子相同。
創建多個進程
很多時候系統都需要創建多個進程以提高CPU的利用率，當數量較少時，可以手動生成一個個Process實例。當進程數量很多時，或許可以利用循環，但是這需要程序員手動管理系統中並發進程的數量，有時會很麻煩。這時進程池Pool就可以發揮其功效了。可以通過傳遞參數限制並發進程的數量，默認值為CPU的核數。
直接上例子：
執行結果：
開頭部分
Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)
末尾部分：
Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.
相關說明：
這里進程池對並發進程的限制數量為8個，而程序運行時會產生16個進程，進程池將自動管理系統內進程的並發數量，其餘進程將會在隊列中等待。限制並發數量是因為，系統中並發的進程不是越多越好，並發進程太多，可能使CPU大部分的時間用於進程調度，而不是執行有效的計算。
採用多進程並發技術時，就單個處理機而言，其對進程的執行是串列的。但具體某個時刻哪個進程獲得CPU資源而執行是不可預知的（如執行結果的開頭部分，各進程的執行順序不定），這就體現了進程的非同步性。
如果單個程序執行14次run_proc函數，那麼它會需要至少16秒,通過進程的並發，這里只需要2.49秒，可見並發的優勢。
Ⅲ 用Python如何實現呢
start_i = 5
result = 1
while(start_i<=500):
if start_i != 99:
result = result * start_i
start_i = start_i + 1
print(result)
Ⅳ python 怎麼實現人工智慧
一、Python是解釋語言，程序寫起來非常方便
寫程序方便對做機器學習的人很重要。 因為經常需要對模型進行各種各樣的修改，這在編譯語言里很可能是牽一發而動全身的事情，Python里通常可以用很少的時間實現。舉例來說，在C等編譯語言里寫一個矩陣乘法，需要自己分配操作數（矩陣）的內存、分配結果的內存、手動對BLAS介面調用gemm、最後如果沒用smart pointer還得手動回收內存空間。Python幾乎就是import numpy; numpy.dot兩句話的事。
當然現在很多面向C/C++庫已經支持託管的內存管理了，這也讓開發過程容易了很多，但解釋語言仍然有天生的優勢——不需要編譯時間。這對機器學習這種需要大量prototyping和迭代的研究方向是非常有益工作效率的。
二、Python的開發生態成熟，有很多有用的庫可以用
Python靈活的語法還使得包括文本操作、list/dict comprehension等非常實用的功能非常容易高效實現（編寫和運行效率都高），配合lambda等使用更是方便。這也是Python良性生態背後的一大原因。相比而言，Lua雖然也是解釋語言，甚至有LuaJIT這種神器加持，但其本身很難做到Python這樣，一是因為有Python這個前輩佔領著市場份額，另一個也因為它本身種種反常識的設計（比如全局變數）。不過借著Lua-Python bridge和Torch的東風，Lua似乎也在寄生興起。
三、Python效率超高
解釋語言的發展已經大大超過許多人的想像。很多比如list comprehension的語法糖都是貼近內核實現的。除了JIT之外，還有Cython可以大幅增加運行效率。最後，得益於Python對C的介面，很多像gnumpy, theano這樣高效、Python介面友好的庫可以加速程序的運行，在強大團隊的支撐下，這些庫的效率可能比一個不熟練的程序員用C寫一個月調優的效率還要高。
未來十年Python語言的發展前景形勢一片大好，毫無疑問使用Python語言的企業將會越來越多，Python程序猿的人才缺口也將越來越大，認准時機，把握機遇，Python全棧開發工程師、Python開發工程師、自動化開發工程師、Linux運維工程師、Python爬蟲開發工程師、前端開發工程師、大數據分析和數據挖掘等熱門職位等你來選。
Ⅳ 用python如何實現啊
from random import randint
class Shengfen(object):
def __init__(self, sname):
self.sname = sname
def shengfen(self):
print(self.sname)
class Dijishi(Shengfen):
def __init__(self, sname, dname):
Shengfen.__init__(self, sname)
self.dname = dname
self.money = 10000 #現有錢數
self.number = 0 #商品數量
self.jycs = 0 #交易次數
def attach_g(self): #聯系供應商
self.money -= 100
self.number += 1
if self.number >= 4:
self.xiaoshou() #庫存積攢到4件時，開始銷售該商品
print("現有錢數：" + str(self.money))
print("現有商品數量：" + str(self.number))
def xiaoshou(self): #銷售該商品
if self.jycs < 4: #交易次數小於4次，繼續交易
self.money += 110
self.number -= 1
self.jycs += 1
else: #交易次數大於4次，又百分之50的幾率退貨
if randint(1,2) == 1: #用randint函數創建1/2概率
self.money += 110
self.number -= 1
else:
self.tuihuo()
def tuihuo(self):
self.money -= 30 #退貨一件，相當於虧了30元
print("退貨一件")
class Gebishi(Shengfen):
def __init__(self, sname, gname):
Shengfen.__init__(self, sname)
self.gname = gname
if __name__ == "__main__":
count = 9 #交易次數
Qinshihuang = Dijishi('Guangdong', 'Guangzhou')
Liubang = Gebishi('Guangdong', 'Foshan')
Hanxin = Gebishi('Guangdong', 'Foshan')
for i in range(count):
Qinshihuang.attach_g()
大致按照要求來寫了一下，可能有些地方還有問題，如果有的話，你留言一下，我再幫你改吧
Ⅵ python語言，如何實現如下小功能
用Python解決稍微有點繁瑣，這里不貼代碼了，我說一下大致思路：
1、Python安裝第三方庫：pyopenxl
2、讀取b列1行的數據，賦值給x，
3、將x的數據中的字元變成單個字母的列表。
4、將x中列表的第一個字母賦值給y
5、將y寫入e列1行
6、遍歷所有行，用for循環重復2-5操作，可以將2-5定義一個函數。
個人建議：雖然Python能夠實現這項工作，但是是不是用編程來解決有點太麻煩了。如果用excel解決會更快一些：
1、復制b列粘貼到e列
2、選中e列，在查找和替換中查找「aaa」替換成「a」；查找「bbb」替換成「b"以此類推
這樣的話一個電子表幾分鍾就能解決問題了。
3、解決問題有很多種辦法，採用最簡單、效率、穩定可行的辦法。不一定非要用編程解決。
Ⅶ python行轉換成列怎麼實現
可以使用Python字元串內置的替換方法把分隔符「，」替換成『 』 換行符即可(Linux、MacOS下換行符為：" ")：
iPython下演示
Ⅷ python 怎麼實現多線程的
線程也就是輕量級的進程，多線程允許一次執行多個線程，Python是多線程語言，它有一個多線程包，GIL也就是全局解釋器鎖，以確保一次執行單個線程，一個線程保存GIL並在將其傳遞給下一個線程之前執行一些操作，也就產生了並行執行的錯覺。
Ⅸ 在python中，怎麼實現輸入
Python的輸入輸出分別是利用函數：
str = input("請輸入：");
print ("你輸入的內容是: ", str)；
input函數返回一個string類型的值，聲明一個變數來接收輸入的值，print是輸出