python三百萬並發

① python 適合大數據量的處理嗎

python可以處理大數據，但是python處理大數據不一定是最優的選擇

公司中，很大量的數據處理工作工作是不需要面對非常大的數據的

② 有沒有人寫過python的一秒3000個並發請求的服務端

3000qps，沒問題，
3000並發連接，tornado，twisted這種非阻塞的也沒問題。。。
python有gil鎖，要多進程才行，
還要看請求邏輯復雜性，返回數據量大小

③ 高並發,用Python適合嗎

Python不太適合高並發，雖然可以做，但是問題還是比較大，特別如果是後端服務，需要很高的高並發的話，還是用其他語言。

要高並發的話， 多進程+協程的組合的並發性能遠高於多線程。我在這篇文章中對python的並發方案有過比較。 像是要發各種請求的，其實和爬蟲類似， 協程的方案比較合適，能達到很高的並發。

Python簡介：

Python由荷蘭數學和計算機科學研究學會的Guido van Rossum於1990 年代初設計，作為一門叫做ABC語言的替代品。

Python提供了高效的高級數據結構，還能簡單有效地面向對象編程。Python語法和動態類型，以及解釋型語言的本質，使它成為多數平台上寫腳本和快速開發應用的編程語言，隨著版本的不斷更新和語言新功能的添加，逐漸被用於獨立的、大型項目的開發。

④ python實現多線程並發執行

由於停服維護的需求(服務越來越多的原因),此前編寫的shell腳本執行速度緩慢(for循環,這就會很慢),為提高執行速度,參考很多資料,完成此腳本,實現並發執行機制.(當然這是測試腳本,有需要的同學,拿去改ba改ba,應該就可以用了)

此處腳本參考了 https://www.jb51.net/article/86053.htm

⑤ python的基礎是什麼

Python的基礎有：

1 標識符

標識符是編程時使用的名字，用於給變數、函數、語句塊等命名，Python 中標識符由字母、數字、下劃線組成，不能以數字開頭，區分大小寫。

以下劃線開頭的標識符有特殊含義，單下劃線開頭的標識符，如：_xxx，表示不能直接訪問的類屬性，需通過類提供的介面進行訪問，不能用from xxx import *導入；雙下劃線開頭的標識符，如：__xx，表示私有成員；雙下劃線開頭和結尾的標識符，如：__xx__，表示 Python 中內置標識，如：__init__()表示類的構造函數。

2 關鍵字

3 引號

Python 可以使用引號（'）、雙引號（"）、三引號（'''或"""）來表示字元串，引號的開始與結束須類型相同，三引號可以由多行組成。

4 編碼

Python2 中默認編碼為ASCII，假如內容為漢字，不指定編碼便不能正確的輸出及讀取，比如我們想要指定編碼為UTF-8，Python 中通過在開頭加入# -*- coding: UTF-8 -*-進行指定。

Python3 中默認編碼為UTF-8，因此在使用 Python3 時，我們通常不需指定編碼。

5 輸入輸出

Python 輸出使用 print()，內容加在括弧中即可。

Python 提供了一個 input()，可以讓用戶輸入字元串，並存放到一個變數里。

6 縮進

Python 不使用{}來控制類、函數、邏輯判斷等，而是使用縮進，縮進的空格可變。

7 多行

Python 中一般以新行作為語句的結束標識，可以使用將一行語句分為多行顯示。

如果包含在[]、{}、()括弧中，則不需要使用。

8 注釋

Python 中單行注釋使用#，多行注釋使用三個單引號（'''）或三個雙引號（"""）。

⑥ 如何在Python中編寫並發程序

GIL

在Python中,由於歷史原因(GIL),使得Python中多線程的效果非常不理想.GIL使得任何時刻Python只能利用一個CPU核,並
且它的調度演算法簡單粗暴:多線程中,讓每個線程運行一段時間t,然後強行掛起該線程,繼而去運行其他線程,如此周而復始,直到所有線程結束.

這使得無法有效利用計算機系統中的"局部性",頻繁的線程切換也對緩存不是很友好,造成資源的浪費.

據說Python官方曾經實現了一個去除GIL的Python解釋器,但是其效果還不如有GIL的解釋器,遂放棄.後來Python官方推出了"利
用多進程替代多線程"的方案,在Python3中也有concurrent.futures這樣的包,讓我們的程序編寫可以做到"簡單和性能兼得".

多進程/多線程+Queue

一般來說,在Python中編寫並發程序的經驗是:計算密集型任務使用多進程,IO密集型任務使用多進程或者多線程.另外,因為涉及到資源共享,所
以需要同步鎖等一系列麻煩的步驟,代碼編寫不直觀.另外一種好的思路是利用多進程/多線程+Queue的方法,可以避免加鎖這樣麻煩低效的方式.

現在在Python2中利用Queue+多進程的方法來處理一個IO密集型任務.

假設現在需要下載多個網頁內容並進行解析,單進程的方式效率很低,所以使用多進程/多線程勢在必行.
我們可以先初始化一個tasks隊列,裡面將要存儲的是一系列dest_url,同時開啟4個進程向tasks中取任務然後執行,處理結果存儲在一個results隊列中,最後對results中的結果進行解析.最後關閉兩個隊列.

下面是一些主要的邏輯代碼.

# -*- coding:utf-8 -*-

#IO密集型任務
#多個進程同時下載多個網頁
#利用Queue+多進程
#由於是IO密集型,所以同樣可以利用threading模塊

import multiprocessing

def main():
tasks = multiprocessing.JoinableQueue()
results = multiprocessing.Queue()
cpu_count = multiprocessing.cpu_count() #進程數目==CPU核數目

create_process(tasks, results, cpu_count) #主進程馬上創建一系列進程,但是由於阻塞隊列tasks開始為空,副進程全部被阻塞
add_tasks(tasks) #開始往tasks中添加任務
parse(tasks, results) #最後主進程等待其他線程處理完成結果

def create_process(tasks, results, cpu_count):
for _ in range(cpu_count):
p = multiprocessing.Process(target=_worker, args=(tasks, results)) #根據_worker創建對應的進程
p.daemon = True #讓所有進程可以隨主進程結束而結束
p.start() #啟動

def _worker(tasks, results):
while True: #因為前面所有線程都設置了daemon=True,故不會無限循環
try:
task = tasks.get() #如果tasks中沒有任務,則阻塞
result = _download(task)
results.put(result) #some exceptions do not handled
finally:
tasks.task_done()

def add_tasks(tasks):
for url in get_urls(): #get_urls() return a urls_list
tasks.put(url)

def parse(tasks, results):
try:
tasks.join()
except KeyboardInterrupt as err:
print "Tasks has been stopped!"
print err

while not results.empty():
_parse(results)

if __name__ == '__main__':
main()

利用Python3中的concurrent.futures包

在Python3中可以利用concurrent.futures包,編寫更加簡單易用的多線程/多進程代碼.其使用感覺和Java的concurrent框架很相似(借鑒?)
比如下面的簡單代碼示例

def handler():
futures = set()

with concurrent.futures.ProcessPoolExecutor(max_workers=cpu_count) as executor:
for task in get_task(tasks):
future = executor.submit(task)
futures.add(future)

def wait_for(futures):
try:
for future in concurrent.futures.as_completed(futures):
err = futures.exception()
if not err:
result = future.result()
else:
raise err
except KeyboardInterrupt as e:
for future in futures:
future.cancel()
print "Task has been canceled!"
print e
return result

總結

要是一些大型Python項目也這般編寫,那麼效率也太低了.在Python中有許多已有的框架使用,使用它們起來更加高效.

⑦ 有沒有人寫過python的一秒3000個並發請求的服務端

雖然沒寫過，但調查過。
我不知道你說的並發是指的單進程還是什麼，如果不限定，前置用Nginx，後置N個web服務，連同一個資料庫，那什麼語言實現你這個級數的並發都是靠堆行硬體。如果是要單個進程達到3000，那麼我的選擇是用tornado，支持微線程，我做過實驗靜態網頁可以做到3000並發

⑧ python高並發怎麼解決

某個時間段內，數據涌來，這就是並發。如果數據量很大，就是高並發

高並發的解決方法：

1、隊列、緩沖區

假設只有一個窗口，陸續湧入食堂的人，排隊打菜是比較好的方式

所以，排隊（隊列）是一種天然解決並發的辦法

排隊就是把人排成 隊列，先進先出，解決了資源使用的問題

排成的隊列，其實就是一個緩沖地帶，就是 緩沖區

假設女生優先，每次都從這個隊伍中優先選出女生出來先打飯，這就是 優先隊列

例如queue模塊的類Queue、LifoQueue、PriorityQueue（小頂堆實現）

2、爭搶

只開一個窗口，有可能沒有秩序，也就是誰擠進去就給誰打飯

擠到窗口的人占據窗口，直到打到飯菜離開

其他人繼續爭搶，會有一個人占據著窗口，可以視為鎖定窗口，窗口就不能為其他人提供服務了。

這是一種鎖機制

誰搶到資源就上鎖，排他性的鎖，其他人只能等候

爭搶也是一種高並發解決方案，但是，這樣可能不好，因為有可能有人很長時間搶不到

3、預處理

如果排長隊的原因，是由於每個人打菜等候時間長，因為要吃的菜沒有，需要現做，沒打著飯不走開，鎖定著窗口

食堂可以提前統計大多數人最愛吃的菜品，將最愛吃的80%的熱門菜，提前做好，保證供應，20%的冷門菜，現做

這樣大多數人，就算鎖定窗口，也很快打到飯菜走了，快速釋放窗口

一種提前載入用戶需要的數據的思路，預處理 思想，緩存常用

更多Python知識，請關註：Python自學網！！

⑨ 有沒有人寫過python的一秒3000個並發請求的服務端

有個國產的web框架：eurasia， 業界大牛 沈老大 寫的，貌似用了stackless python

自己寫了一個tcp的server，epoll based，測過並發60k，不是web框架，沒測過每秒請求數。
python搭tcp/web server都很快，現成的web框架多，裸tcp的框架少

⑩ python簡單的並發問題

• #!/usr/bin/envpython#-*-coding:utf-8-*-#author:ChanghuaGongimporttime,threading#fromurllib.requestimportRequest,urlopenpy3#fromurllib.#URLreq=urllib2.Request('http://47.93.169.69:10080/pigeon-web/user/user

• #!/usr/bin/env python

  # -*- coding:utf-8 -*-

  # author: Changhua Gong

  import time,threading

  # from urllib.request import Request, urlopen py3

  # from urllib.error import URLError py3

  import urllib2

  #URL

  req = urllib2.Request('http://47.93.169.69:10080/pigeon-web/user/userExtraInfo?userId=1')

  #

  rule = {0:500,1:30}

  '''

  Rule規則:0:50,第一次運行不睡眠即為0,直接並發50次;1:20,第二秒,相當於睡眠1秒,然後並發20次,

  如第三秒需並發500次,則rule = {0:50,1:20,1:500}

  '''

  #Open url

  def geturl():

  time_b = time.time()

  try:

  response = urllib2.urlopen(req)

  print(response.read().decode("utf-8")) # 列印輸出內容

  except urllib2.URLError as e:

  if hasattr(e, 'reason'):

  print('We failed to reach a server.')

  print('Reason: ', e.reason)

  elif hasattr(e, 'code'):

  print('The server couldn/'t fulfill the request.')

  print('Error code: ', e.code)

  time_e = time.time()

  print("Thread %s runned for %ss" % (threading.current_thread().name, (time_e - time_b))) #線程訪問時效

  if __name__=='__main__':

  for k in rule:

  time.sleep(k)

  for i in range(rule[k]):

  t = threading.Thread(target=geturl)

  t.start()