pythonifstop
❶ 一个python函数的问题
按照您的code,代码是无法编译的,简单的例证见图片。
另外,您的代码是不是应该这样:
definterval(start,stop=None,step=1):
ifstopisNone:
start,stop=0,start
step=1
printstart,'',stop,'',step
调用的时interval(10)
结果是0101
是因为start,stop=0,start这一句,把0赋给start,start的值赋给stop
❷ 急求Python高手!!!Python Tkinter 中的什么组件可以流动显示文字或者如何实现文字流动显示
试一试这个是否符合你的需求。
fromTkinterimport*
importtime
root=Tk()
root.title("Marquee")
root.geometry("320x240+100+100")
show_str=StringVar(root)
show_str.set("this")
source_str="Thisisalongstring."
stopflag=True
pos=0
defmarquee(widget):
textwidth=10
strlen=len(source_str)
globalpos
ifstrlen-pos<10:
show_str.set(source_str[pos:pos+textwidth]+source_str[0:10-strlen+pos])
else:
show_str.set(source_str[pos:pos+textwidth])
pos+=1
ifpos>strlen:
pos=0
globalstopflag
ifstopflag:
widget.after(300,marquee,widget)
show_lb=Label(root,textvariable=show_str)
show_lb.place(x=20,y=20,width=200,height=30)
defstartmarque():
globalstopflag
stopflag=True
marquee(show_lb)
defstopmarquee():
globalstopflag
stopflag=False
button1=Button(root,text="start",command=startmarque)
button2=Button(root,text="stop",command=stopmarquee)
button1.place(x=20,y=100,width=50,height=30)
button2.place(x=200,y=100,width=50,height=30)
root.mainloop()
❸ python这个小程序运行步骤谁能解释下。为什么print interval(10)输出的是0到9而不是9到0
definterval(start,stop=None,step=1):
#start=10;stop=None,step=1
ifstopisNone:#stop=None,符合条件进入
start,stop=0,start
#start=0;stop=10
result=[]
i=start
#i=0
whilei<stop:
result.append(i)
#result依次存入的值为0,1,2,3,4,5,6,7,8,9
i+=step
returnresult
#返回result
printinterval(10);#结构就是打印[0,1,2,3,4,5,6,7,8,9]
❹ 如何用Python编写一个聊天室
python聊天室(python2.7版本):
暂时先给出两种版本的,tcp+udp
都是分别运行server.py和client.py,就可以进行通讯了。
别外还有websocket版本,这个是有web界面的和基本web服务的,如果需要的话,我会把基本的代码贴一版上来。
TCP版本:
socket-tcp-server.py(服务端):
#-*-encoding:utf-8-*-
#socket.getaddrinfo(host,port,family=0,socktype=0,proto=0,flags=0)
#根据给定的参数host/port,相应的转换成一个包含用于创建socket对象的五元组,
#参数host为域名,以字符串形式给出代表一个IPV4/IPV6地址或者None.
#参数port如果字符串形式就代表一个服务名,比如“http”"ftp""email"等,或者为数字,或者为None
#参数family为地主族,可以为AF_INET,AF_INET6,AF_UNIX.
#参数socktype可以为SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)
#参数proto通常为0可以直接忽略
#参数flags为AI_*的组合,比如AI_NUMERICHOST,它会影响函数的返回值
#附注:给参数host,port传递None时建立在C基础,通过传递NULL。
#该函数返回一个五元组(family,socktype,proto,canonname,sockaddr),同时第五个参数sockaddr也是一个二元组(address,port)
#更多的方法及链接请访问
#Echoserverprogram
fromsocketimport*
importsys
importthreading
fromtimeimportctime
fromtimeimportlocaltime
importtraceback
importtime
importsubprocess
reload(sys)
sys.setdefaultencoding("utf8")
HOST='127.0.0.1'
PORT=8555#设置侦听端口
BUFSIZ=1024
classTcpServer():
def__init__(self):
self.ADDR=(HOST,PORT)
try:
self.sock=socket(AF_INET,SOCK_STREAM)
print'%disopen'%PORT
self.sock.bind(self.ADDR)
self.sock.listen(5)
#设置退出条件
self.STOP_CHAT=False
#所有监听的客户端
self.clients={}
self.thrs={}
self.stops=[]
exceptException,e:
print"%disdown"%PORT
returnFalse
defIsOpen(ip,port):
s=socket(AF_INET,SOCK_STREAM)
try:
s.connect((ip,int(port)))
#s.shutdown(2)
#利用shutdown()函数使socket双向数据传输变为单向数据传输。shutdown()需要一个单独的参数,
#该参数表示s了如何关闭socket。具体为:0表示禁止将来读;1表示禁止将来写;2表示禁止将来读和写。
print'%disopen'%port
returnTrue
except:
print'%disdown'%port
returnFalse
deflisten_client(self):
whilenotself.STOP_CHAT:
print(u'等待接入,侦听端口:%d'%(PORT))
self.tcpClientSock,self.addr=self.sock.accept()
print(u'接受连接,客户端地址:',self.addr)
address=self.addr
#将建立的clientsocket链接放到列表self.clients中
self.clients[address]=self.tcpClientSock
#分别将每个建立的链接放入进程中,接收且分发消息
self.thrs[address]=threading.Thread(target=self.readmsg,args=[address])
self.thrs[address].start()
time.sleep(0.5)defreadmsg(self,address):
#如果地址不存在,则返回False
ifaddressnotinself.clients:
returnFalse
#得到发送消息的clientsocket
client=self.clients[address]
whileTrue:
try:
#获取到消息内容data
data=client.recv(BUFSIZ)
except:
print(e)
self.close_client(address)
break
ifnotdata:
break
#python3使用bytes,所以要进行编码
#s='%s发送给我的信息是:[%s]%s'%(addr[0],ctime(),data.decode('utf8'))
#对日期进行一下格式化
ISOTIMEFORMAT='%Y-%m-%d%X'
stime=time.strftime(ISOTIMEFORMAT,localtime())
s=u'%s发送给我的信息是:%s'%(str(address),data.decode('utf8'))
#将获得的消息分发给链接中的clientsocket
forkinself.clients:
self.clients[k].send(s.encode('utf8'))
self.clients[k].sendall('sendall:'+s.encode('utf8'))
printstr(k)
print([stime],':',data.decode('utf8'))
#如果输入quit(忽略大小写),则程序退出
STOP_CHAT=(data.decode('utf8').upper()=="QUIT")
ifSTOP_CHAT:
print"quit"
self.close_client(address)
print"alreadyquit"
break
defclose_client(self,address):
try:
client=self.clients.pop(address)
self.stops.append(address)
client.close()
forkinself.clients:
self.clients[k].send(str(address)+u"已经离开了")
except:
pass
print(str(address)+u'已经退出')
if__name__=='__main__':
tserver=TcpServer()
tserver.listen_client()
——————————华丽的分割线——————————
socket-tcp-client.py(客户端):
#-*-encoding:utf-8-*-
fromsocketimport*
importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding("utf8")
#测试,连接本机
HOST='127.0.0.1'
#设置侦听端口
PORT=8555
BUFSIZ=1024
classTcpClient:
ADDR=(HOST,PORT)
def__init__(self):
self.HOST=HOST
self.PORT=PORT
self.BUFSIZ=BUFSIZ
#创建socket连接
self.client=socket(AF_INET,SOCK_STREAM)
self.client.connect(self.ADDR)
#起一个线程,监听接收的信息
self.trecv=threading.Thread(target=self.recvmsg)
self.trecv.start()
defsendmsg(self):
#循环发送聊天消息,如果socket连接存在则一直循环,发送quit时关闭链接
whileself.client.connect_ex(self.ADDR):
data=raw_input('>:')
ifnotdata:
break
self.client.send(data.encode('utf8'))
print(u'发送信息到%s:%s'%(self.HOST,data))
ifdata.upper()=="QUIT":
self.client.close()
printu"已关闭"
break
defrecvmsg(self):
#接收消息,如果链接一直存在,则持续监听接收消息
try:
whileself.client.connect_ex(self.ADDR):
data=self.client.recv(self.BUFSIZ)
print(u'从%s收到信息:%s'%(self.HOST,data.decode('utf8')))
exceptException,e:
printstr(e)
if__name__=='__main__':
client=TcpClient()
client.sendmsg()
UDP版本:
socket-udp-server.py
#-*-coding:utf8-*-
importsys
importtime
importtraceback
importthreading
reload(sys)
sys.setdefaultencoding('utf-8')
importsocket
importtraceback
HOST="127.0.0.1"
PORT=9555
CHECK_PERIOD=20
CHECK_TIMEOUT=15
classUdpServer(object):
def__init__(self):
self.clients=[]
self.beats={}
self.ADDR=(HOST,PORT)
try:
self.sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.sock.bind(self.ADDR)#绑定同一个域名下的所有机器
self.beattrs=threading.Thread(target=self.checkheartbeat)
self.beattrs.start()
exceptException,e:
traceback.print_exc()
returnFalse
deflisten_client(self):
whileTrue:
time.sleep(0.5)
print"hohohohohoo"
try:
recvData,address=self.sock.recvfrom(2048)
ifnotrecvData:
self.close_client(address)
break
ifaddressinself.clients:
senddata=u"%s发送给我的信息是:%s"%(str(address),recvData.decode('utf8'))
ifrecvData.upper()=="QUIT":
self.close_client(address)
ifrecvData=="HEARTBEAT":
self.heartbeat(address)
continue
else:
self.clients.append(address)
senddata=u"%s发送给我的信息是:%s"%(str(address),u'进入了聊天室')
forcinself.clients:
try:
self.sock.sendto(senddata,c)
exceptException,e:
printstr(e)
self.close_client(c)
exceptException,e:
#traceback.print_exc()
printstr(e)
pass
defheartbeat(self,address):
self.beats[address]=time.time()
defcheckheartbeat(self):
whileTrue:
print"checkheartbeat"
printself.beats
try:
forcinself.clients:
printtime.time()
printself.beats[c]
ifself.beats[c]+CHECK_TIMEOUT<time.time():
printu"%s心跳超时,连接已经断开"%str(c)
self.close_client(c)
else:
printu"checkp%s,没有断开"%str(c)
exceptException,e:
traceback.print_exc()
printstr(e)
pass
time.sleep(CHECK_PERIOD)
defclose_client(self,address):
try:
ifaddressinself.clients:
self.clients.remove(address)
ifself.beats.has_key(address):
delself.beats[address]
printself.clients
forcinself.clients:
self.sock.sendto(u'%s已经离开了'%str(address),c)
print(str(address)+u'已经退出')
exceptException,e:
printstr(e)
raise
if__name__=="__main__":
udpServer=UdpServer()
udpServer.listen_client()
——————————华丽的分割线——————————
socket-udp-client.py:
#-*-coding:utf8-*-
importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding('utf-8')
importsocket
HOST="127.0.0.1"
PORT=9555
#BEAT_PORT=43278
BEAT_PERIOD=5
classUdpClient(object):
def__init__(self):
self.clientsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.HOST=HOST
self.ADDR=(HOST,PORT)
self.clientsock.sendto(u'请求建立链接',self.ADDR)
self.recvtrs=threading.Thread(target=self.recvmsg)
self.recvtrs.start()
self.hearttrs=threading.Thread(target=self.heartbeat)
self.hearttrs.start()
defsendmsg(self):
whileTrue:
data=raw_input(">:")
ifnotdata:
break
self.clientsock.sendto(data.encode('utf-8'),self.ADDR)
ifdata.upper()=='QUIT':
self.clientsock.close()
break
defheartbeat(self):
whileTrue:
self.clientsock.sendto('HEARTBEAT',self.ADDR)
time.sleep(BEAT_PERIOD)
defrecvmsg(self):
whileTrue:
recvData,addr=self.clientsock.recvfrom(1024)
ifnotrecvData:
break
print(u'从%s收到信息:%s'%(self.HOST,recvData.decode('utf8')))if__name__=="__main__":
udpClient=UdpClient()
udpClient.sendmsg()
❺ Python里如何终止一个线程
Python用sleep停止一个线程的运行,而不影响主线程的运行,案例代码如下:
fromthreadingimport*
importtime
classMyThread(Thread):
defrun(self):
self.ifdo=True;
whileself.ifdo:
print'Iamrunning...'
time.sleep(2)
defstop(self):
print'Iamstoppingit...'
self.ifdo=False;
tr=MyThread()
tr.setDaemon(True)
tr.start()
print'Iwillstopit...'
time.sleep(5)
tr.stop()
tr.join()
❻ 求问下面这段python中的第8行,那个list后面跟两个[]是什么用法谢谢!
这段程序用涉及到了递归调用,就是自己调用自己。而其中的prevlist是由不断缩短的字符串组成的列表。
由于后续需要对数组中的元素进行操作,所以用到第一个[ ]进行索引;但由于构成字符串的字符可能多于一个字符,而程序又针对一个或者几个个字符构成的小段进行重新排列,所以用到第二个[ ],于是就有了两个[ ]同时出现的现象。
❼ python输入若干个数,输入stop,停止,并找出最大的数,最小的数,和所有数的和。
为了好玩,全写在一行:
print"len=%r,max=%r,min=%r,sum=%r"%tuple(map(lambdax,h=(lambdawh=[]:wh.append(lambdaaa=[]:(lambdaa=raw_input():a.upper()!='STOP'and(aa.append(int(a)),wh[0]())andaa)())orwh[0]())():apply(x,(h,)),(len,max,min,sum)))
❽ python怎么让进程暂停
您的意思是要将进程挂起(Suspend) 而非 阻塞(Block)
如果用sleep() 进程将阻塞
假设进程下有两个线程 那么这两个线程会继续运行
要使进程挂起 可以考虑使用psutil
import psutil
p = psutil.Process(pid)
p.suspend() #挂起进程
p.resume() #恢复进程
为了证明效果 我写了一个简单的进程Process
其下有两个线程 读者Reader 和 写者Writer(简单的读者写者问题)
Process:
import threading
from time import ctime, sleep
import ThreadInReadAndWriteProblem
import multiprocessing
import os
class Process(multiprocessing.Process):
def __init__(self):
multiprocessing.Process.__init__(self) #手动实现父类
pid = os.getpid()
def run(self):
print '当前运行进程PID : %s ' %self.pid #子线程的id与父进程的pid相同 属于 同一个进程
for i in range(0,5):
r = ThreadInReadAndWriteProblem.Reader()
w = ThreadInReadAndWriteProblem.Writer()
w.start()
r.start()
print '进程阻塞'
sleep(10) #总共运行时间10秒
Reader&Writer
import threading
from time import ctime, sleep
import os
mutex = threading.Lock() #互斥锁
mutex_readercount = threading.Lock() #计数时的互斥 计算当前正在读的数目
readerCount = 0 number = 0
#不满足条件的 进入阻塞状态
class Reader(threading.Thread): #读者
def __init__(self):
threading.Thread.__init__(self) #继承父类构造函数
def run(self):
global mutex
global readerCount
#print '线程PID: %s ' %os.getpid()
while True:
mutex_readercount.acquire()
readerCount +=1
if readerCount == 1:
print '读者进程等待中,编号%s' %(self.name)
mutex.acquire() == False # 第一个需要申请
mutex_readercount.release()
print '开始读 , 读者编号 %s ,现在时间是 %s' %(self.name,ctime())
sleep(2)
print '完成读 , 读者编号 %s , 现在时间是 %s' %(self.name,ctime())
mutex_readercount.acquire()
readerCount -= 1
if readerCount == 0: #所有读者均完成
print '最后一个读者完成读 '
mutex.release()
mutex_readercount.release()
class Writer(threading.Thread): #写者
def __init__(self):
threading.Thread.__init__(self)
def run(self):
global mutex
global writerCount
#print '线程PID: %s' %os.getpid()
while True:
print '写者进程等待中 编号: %s' %(self.name)
mutex.acquire()
print '开始写 编号:%s 现在时间是: %s ' %(self.name,ctime())
sleep(5)
print '结束写 编号: %s 现在时间是 %s' %(self.name,ctime())
mutex.release()
测试程序
import ThreadInReadAndWriteProblem
import
import psutil
import Scheler
from time import ctime, sleep
def main():
p = .Process()
p.start()
sleep(3)
stop(p.pid)
print '进程挂起 %s' %ctime()
sleep(5)
wake(p.pid)
print '唤醒进程 %s' %ctime()
def stop(pid):
print '进程暂停 进程编号 %s ' %(pid)
p = psutil.Process(pid)
p.suspend()
def wake(pid):
print '进程恢复 进程编号 %s ' %(pid)
p = psutil.Process(pid)
p.resume()
if __name__ == '__main__':
main()
结果:
当前运行进程PID : 3096
写者进程等待中 编号: Thread-2
开始写 编号:Thread-2 现在时间是: Mon Nov 30 21:12:12 2015
读者进程等待中,编号Thread-1
写者进程等待中 编号: Thread-4
进程阻塞
写者进程等待中 编号: Thread-6
写者进程等待中 编号: Thread-8
写者进程等待中 编号: Thread-10
进程暂停 进程编号 3096
进程挂起 Mon Nov 30 21:12:15 2015
进程恢复 进程编号 3096
唤醒进程 Mon Nov 30 21:12:20 2015
结束写 编号: Thread-2 现在时间是 Mon Nov 30 21:12:20 2015
写者进程等待中 编号: Thread-2
开始读 , 读者编号 Thread-1 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-3 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-5 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-7 ,现在时间是 Mon Nov 30 21:12:20 2015
开始读 , 读者编号 Thread-9 ,现在时间是 Mon Nov 30 21:12:20 2015
完成读 , 读者编号 Thread-1 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-3 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-5 , 现在时间是 Mon Nov 30 21:12:22 2015
完成读 , 读者编号 Thread-7 , 现在时间是 Mon Nov 30 21:12:22 2015