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()