python多线程读取文件

❶ python py文件同时开两个线程可以吗

可以的。
Python 多线程
多线程类似于同时执行多个不同程序，多线程运行有如下优点：

使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
程序的运行速度可能加快
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
线程在执行过程中与进程还是有区别的。每个独立的进程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

线程可以被抢占（中断）。
在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。

❷ python 多进程读取同一个循环处理、可以用multiprocessing

可以每个在func中加上一个参数data,data是这个线程处理的数据；

多线程处理的时候，给每个线程分配相应的data就可以了。

给个示例：

#-*-coding:utf-8-*-
importthread,threading
importtime

defFuncTest(tdata):
printtdata

classmythread(threading.Thread):
def__init__(self,threadname):
threading.Thread.__init__(self)

defrun(self):
lock.acquire()
FuncTest(ft)
lock.release()

defMutiThread(num):
threads=[]
i=0
globalft
forxinxrange(num):
threads.append(mythread(num))
fortinthreads:
time.sleep(0.5)
lock.acquire()
ft=GetThreadParam(datafile,num,i)
#print'[%s]Thread:%s,Testdata:%s'%(time.ctime(),t,ft)
i=i+1
t.start()
lock.release()
fortinthreads:
t.join()

defGetThreadParam(datafile,num,curthread):
#线程数需要小于文件行数
f=open(datafile,'r')
lines=f.readlines()
divres=divmod(len(lines),num)
ifcurthread<(num-1):
res=lines[curthread*divres[0]:(curthread+1)*divres[0]]
elifcurthread==(num-1):
res=lines[curthread*divres[0]:((curthread+1)*divres[0]+divres[1])]
returnres
f.close()

if__name__=='__main__':

globalnum,lock
datafile='a.txt'

num=3#num并发数

lock=threading.Lock()
MutiThread(num)

a.txt文件内容如下

1

2

3

4

5

6

7

8

9

10

3个线程并发时，运行结果：

>>>

['1 ', '2 ', '3 ']

['4 ', '5 ', '6 ']

['7 ', '8 ', '9 ', '10']

❸ 日志文件太大，python怎么分割文件，多线程操作

python的多线程为伪多线程，多线程并不能提高文件IO的速度，在读取文件时使用直接读取 for line in open('文件名', 'r') 效率最高，因为此方式为直接读取，不像其它方式要把文件全部加载到内存再读取，所以效率最高。分割时文件时，提前计算好行数，把读取的每固定数量的行数存入新文件，直接读取完成，最后删除旧文件，即可实现文件分割。

示意代码：

line_count=0
index=0
fw=open('part'+str(index)+'.log','w')
forlineinopen('filename.log','r'):
fw.write(line)
line_count+=1
#假设每10000行写一个文件
ifline_count>10000:
fw.close()
index+=1
fw=open('part'+str(index)+'.log','w')
fw.close()

❹ python循环怎么用多线程去运行

背景：Python脚本：读取文件中每行，放入列表中；循环读取列表中的每个元素，并做处理操作。
核心：多线程处理单个for循环函数调用
模块：threading
第一部分：

：多线程脚本 (该脚本只有两个线程，t1循环次数<t2)#!/usr/bin/env python#-*- coding: utf8 -*- import sysimport timeimport stringimport threadingimport datetimefileinfo = sys.argv[1] # 读取文件内容放入列表host_list = []port_list = [] # 定义函数：读取文件内容放入列表中def CreateList(): f = file(fileinfo,'r') for line in f.readlines(): host_list.append(line.split(' ')[0]) port_list.append(line.split(' ')[1]) return host_list return port_list f.close() # 单线程 循环函数，注释掉了#def CreateInfo(): # for i in range(0,len(host_list)): # 单线程：直接循环列表# time.sleep(1)# TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')# print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark)# # 定义多线程循环调用函数def MainRange(start,stop): #提供列表index起始位置参数 for i in range(start,stop): time.sleep(1) TimeMark = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') print "The Server's HostName is %-15s and Port is %-4d !!! [%s]" % (host_list[i],int(port_list[i]),TimeMark) # 执行函数，生成列表CreateList()# 列表分割成：两部分 mid为列表的index中间位置mid = int(len(host_list)/2) # 多线程部分threads = []t1 = threading.Thread(target=MainRange,args=(0,mid))threads.append(t1)t2 = threading.Thread(target=MainRange,args=(mid,len(host_list)))threads.append(t2) for t in threads: t.setDaemon(True) t.start()t.join()print "ok"

以上是脚本内容！！！
----------------------------------------------------------------------
：读取文件的内容
文件内容：
[root@monitor2 logdb]# cat hostinfo.txt
192.168.10.11 1011
192.168.10.12 1012
192.168.10.13 1013
192.168.10.14 1014
192.168.10.15 1015
192.168.10.16 1016
192.168.10.17 1017
192.168.10.18 1018
192.168.10.19 1019
192.168.10.20 1020
192.168.10.21 1021
192.168.10.22 1022
192.168.10.23 1023
192.168.10.24 1024
192.168.10.25 1025

：输出结果：
单线程 : 执行脚本：输出结果：
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.10 and Port is 1010 !!! [2017-01-10 14:25:14]
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:25:15]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:25:16]
.
.
.
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:25:29]

多线程：执行脚本：输出 结果
[root@monitor2 logdb]# ./Threadfor.py hostinfo.txt
The Server's HostName is 192.168.10.11 and Port is 1011 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.18 and Port is 1018 !!! [2017-01-10 14:51:51]
The Server's HostName is 192.168.10.12 and Port is 1012 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.19 and Port is 1019 !!! [2017-01-10 14:51:52]
The Server's HostName is 192.168.10.13 and Port is 1013 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.20 and Port is 1020 !!! [2017-01-10 14:51:53]
The Server's HostName is 192.168.10.14 and Port is 1014 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.21 and Port is 1021 !!! [2017-01-10 14:51:54]
The Server's HostName is 192.168.10.15 and Port is 1015 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.22 and Port is 1022 !!! [2017-01-10 14:51:55]
The Server's HostName is 192.168.10.16 and Port is 1016 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.23 and Port is 1023 !!! [2017-01-10 14:51:56]
The Server's HostName is 192.168.10.17 and Port is 1017 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.24 and Port is 1024 !!! [2017-01-10 14:51:57]
The Server's HostName is 192.168.10.25 and Port is 1025 !!! [2017-01-10 14:51:58]

❺ python怎么读取文件名的内容

python读取文件内容的方法：
一.最方便的方法是一次性读取文件中的所有内容并放置到一个大字符串中：
all_the_text = open('thefile.txt').read( )
# 文本文件中的所有文本
all_the_data = open('abinfile','rb').read( )
# 二进制文件中的所有数据
为了安全起见，最好还是给打开的文件对象指定一个名字，这样在完成操作之后可以迅速关闭文件，防止一些无用的文件对象占用内存。举个例子，对文本文件读取：
file_object = open('thefile.txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )
不一定要在这里用Try/finally语句，但是用了效果更好，因为它可以保证文件对象被关闭，即使在读取中发生了严重错误。
二.最简单、最快，也最具Python风格的方法是逐行读取文本文件内容，并将读取的数据放置到一个字符串行表中：
list_of_all_the_lines = file_object.readlines( )
这样读出的每行文本末尾都带有"\n"符号；如果你不想这样，还有另一个替代的办法，比如：
list_of_all_the_lines = file_object.read( ).splitlines( )
list_of_all_the_lines = file_object.read( ).split('\n')
list_of_all_the_lines = [L.rstrip('\n') for L in file_object]
最简单最快的逐行处理文本文件的方法是，用一个简单的for循环语句：
for line in file_object:
process line
这种方法同样会在每行末尾留下"\n"符号；可以在for循环的主体部分加一句：
lineline = line.rstrip('\n')
或者，你想去除每行的末尾的空白符（不只是'\n'\），常见的办法是：
lineline = line.rstrip( )

❻ 用python读取文本文件，对读出的每一行进行操作，这个怎么写

用python读取文本文件，对读出的每一行进行操作，写法如下：

f=open("test.txt","r")

whileTrue:

line=f.readline()

ifline:

pass#dosomethinghere

line=line.strip()

p=line.rfind('.')

filename=line[0:p]

print"create%s"%line

else:

break

f.close()

❼ python如何使用多线程抓取多个log

由于python是一种解释性脚本语言，python的多线程在运行过程中始终存在全局线程锁。简单的来说就是在实际的运行过程中，python只能利用一个线程，因此python的多线程并不达到C语言多线程的性能。可以使用多进程来代替多线程，但需要注意的是多进程最好不要涉及到例如文件操作的频繁操作IO的功能。

❽ python多线程爬取文件，怎么设置超时重连

你可以试试直接使用开源的爬虫库scrapy，原生支持多线程，还可以设定抓取速率，并发线程数等等参数；除此之外，scrapy对爬虫提取HTML内容也有良好的支持。

❾ 如何用多线程读取大文件并且做数据处理，100

先说几个要点：

a、文件在操作系统级，有描述符标记，关联到打开的文件表项，文件表项纪录了一个很重要的信息，当前文件的指针；
b、cpu要干的工作比读文件快不，读一次文件的速度要慢于cpu处理一次的速度，没必要多多线程，多线程提升不了多少性能，还增加编程的难度，单线程处理即可。
c、待处理文件，必须知道一定的边界值，如分页边界或单条纪录边界。
有了上面的前提，每个线程维护单独的缓冲区，缓存区大小就是c点提到的边界纪录大小。线程启动，把缓冲区读满，处理数据。此处有个要点，必须做文件锁，把要读的边界锁住。否则读出来的数据会产生混乱。（如果强行打开多个不同的文件不划算，内存占用可能会过多）。产生混乱的原因简单，读文件实际上是进行系统调用，系统调用有自己的缓冲区，这缓冲区未必跟你设置的缓冲区一样大。多次读多次移动指针，不加文件锁处理的数据必定会乱。
文件锁两种方式加锁，对整个文件加锁，对字节区间加锁。都不是什么难事。
实现方式1:对整个文件加锁，因为我们要保证的是读到的数据别混乱。
实现方式2:如果内存足够大，维护n个独立的文件描述符，这些文件描述符必须有独立的文件指针，操作系统上有对应实现。每个线程操作未读纪录，这么做还需要维护共享的已读纪录指针。防止重复处理。这么做处理完成如果需要按顺序合并文件是难点。处理过的数据有新的纪录边界。要视实际情况而定能不能这么做。写程序要优先保证的是正确性，之后才是提升效率。
我说的理论，依据是操作系统提供的api处理。别的语言要依赖操作系统运行。原理差不多，目标语言有没有操作系统提供的api强悍。依据使用的目标语言而定。绝大多数能叫编程语言的语言都会提供操作系统api对应的方法。（脚本语言例外，如shell，perl，javascript，vbscript，就可能没这么强的控制能力。），java，objective-c，swift，php，python一般是不会有问题的。

❿ 有3个文件1.txt 2.txt 3.txt 我想利用python多线程同时查看3个文件的内容

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


defread(file_uri):
withopen(file_uri)asfp:
foriinfp.readlines():
printfile_uri,i


a=threading.Thread(name='daemon',target=read,args=('1.txt',))
a.setDaemon(True)
a.start()

b=threading.Thread(name='daemon',target=read,args=('2.txt',))
b.setDaemon(True)
b.start()

c=threading.Thread(name='daemon',target=read,args=('3.txt',))
c.setDaemon(True)
c.start()

a.join()
b.join()
c.join()

不知道你为什么有这样的要求，其实没啥意义。如果想分次读取文件，会让内容变乱，如果想顺序，还要枷锁，还不如不使用线程了。

如果解决了您的问题请采纳！
如果未解决请继续追问