精华内容
下载资源
问答
  • 实现异步调用之前我们先进行什么是同步调用和异步调用 同步:是指完成事务的逻辑,先执行第一个事务,如果阻塞了,会一直等待,直到这个事务完成,再执行第二个事务,顺序执行 异步:是和同步相对的,异步是指在...
  • 不知道大家有没有这样一个烦恼,“自己的电脑总是被别人使用,又不好意思设置密码”,所以利用python设计了一个程序来实现自由管控。 功能虽然简单,但大家可以通过其思路来实现更多的功能。 大致功能主要是两个部分...
  • 不知道大家有没有这样一个烦恼,“自己的电脑总是被别人使用,又不好意思设置密码”,所以利用python设计了一个程序来实现自由管控。功能虽然简单,但大家可以通过其思路来实现更多的功能。大致功能主要是两个部分,...

    不知道大家有没有这样一个烦恼,“自己的电脑总是被别人使用,又不好意思设置密码”,所以利用python设计了一个程序来实现自由管控。

    功能虽然简单,但大家可以通过其思路来实现更多的功能。

    大致功能主要是两个部分,

    一、电脑开机时,我的手机能收到通知。

    二、可以通过手机发个特定的mail,就可以控制电脑关机。

    第一个步骤:申请一个邮箱,使这个邮箱与你的手机号码绑定,然后你在这个邮箱中设定如果有新的邮件就发短信通知,这样开机时往这个邮箱发个mail,我手机就会收到短信通知了。

    第二个步骤:通过python 脚本,定时去检查163.com邮箱中是否有指定的邮件,如果有,则执行特定功能(我的是关机)。

    第一步骤申请成功以后。手机也可以通过一个号码10658139来发送mail,编辑短信格式如:test@163.com(空格)主旨(空格)正文.

    这样我如果想关机,就会用手机发个mail到163邮箱,主旨是'关机',程式检测到这个mail以后就会执行关机动作。

    注意:手机发送邮件时的格式,注意读取邮件时get_payload的输出,根据输出和你发的邮件内容要匹配,当时我就遇到 的问题。

    回去后想了想,既然可以用手机邮箱控制,那么大家都用的是智能机咯,而且大家都比较喜欢玩微信,那么微信里面有个邮箱助手,实时提醒你新邮件,这样可以更方便的控制你自己的机子咯!!!!!

    #!/etc/bin/env python

    #-*-encoding=utf-8-*-

    #auth@:dengyongkai

    #blog@:blog.sina.com.cn/kaiyongdeng

    import poplib,email

    from email.header import decode_header

    import smtplib

    import time

    import os,sys

    import random

    def accp_mail():

    try:

    p=poplib.POP3('pop.qq.com')

    p.user('用户名')

    p.pass_('密码')

    ret = p.stat()

    except poplib.error_proto,e:

    return 1

    print "Login failed:",e

    sys.exit(1)

    # for i in range(1,ret[0]+1):

    # str=s.top(i,0)

    # strlist=[]

    # for x in str[1]:

    # try:

    # strlist.append(x.decode())

    # except:

    # try:

    # strlist.append(x.decode('gbk'))

    # except:

    # strlist.append(x.decode('big5'))

    #

    # mm = email.message_from_string(' '.join(strlist))

    # sub=decode_header(mm['subject'])

    # if sub[0][1]:

    # submsg = sub[0][0].decode(sub[0][1])

    # else:

    # submsg = sub[0][0]

    #

    # if submsg.strip()=='startpc':

    # s.dele(i)

    # return 0

    #

    # s.quit()

    # return 1

    #

    for item in p.list()[1]:

    number,octets = item.split(' ')

    # print "Message %s: %sbytes"%(number,octets)

    lines = p.retr(number)[1]

    msg = email.message_from_string(" ".join(lines))

    # print msg.as_string()

    print msg.get_payload()

    if msg.get_payload()=="start ":

    return 0

    def send_mail():

    try:

    handle = smtplib.SMTP('smtp.163.com', 25)

    handle.login('********@163.com','密码')

    msg = "To: ********@qq.com From: ********@163.com Subject: startpc start "

    handle.sendmail('********@163.com','********@qq.com', msg)

    handle.close()

    return 1

    except:

    return 0

    if __name__=='__main__':

    while send_mail()==0:

    time.sleep(2)

    while 1:

    time.sleep(5)

    if accp_mail()==0:

    os.system('shutdown -f -s -t 10 -c closing...')

    #print "哈哈哈哈哈哈哈,成功啦!!!!!!"

    break

    以上就是python实现远程控制电脑的方法,解决了大家的烦恼,赶紧试验一下吧!

    本文标题: python如何实现远程控制电脑(结合微信)

    本文地址: http://www.cppcns.com/jiaoben/python/137603.html

    展开全文
  • 利用Python如何监控系统进程?Scrapy的中间件如何利用起来?python如何与操作系统交互?

    1.项目环境

    基于 Python3.7 ,使用 Scrapy框架,正常抓取某网站搜索指数排名。

    2.需求背景

    由于网络时好时坏,有时候会遇到timeout这种延时错误,出错之后爬虫便会停止,如果没有第一时间重启,或者是排错,抓取效率便会十分低下。所以便想着有没有解决方法(爬虫项目是同事写的,跑在我电脑上,实习生打杂就完事了

    3.解决思路

    • 1.利用另外一个Python程序,监控该爬虫进程是否正常进行,同理也可以扩展到监控其他的程序是否正常运行。

    • 2.利用Scrapy框架自身提供的中间件进行错误处理

    3.1 进程监控

    实现进程监控需要解决以下问题

    1. 如何用python获取电脑中运行的进程?
    2. 如何知道要监控的进程是否存活?

    第一个问题使用python提供的os库可以解决

    os.popen('tasklist')
    

    tasklist : 输出电脑上当前所执行的程序名已经进程编号PID

    该方法类似与在cmd命令行下所执行的效果一样,会将在cmd下执行的结果输出到缓冲流,因此我们也需要从缓冲流中把结果读出来。

    os.popen('tasklist').read()
    

    第二个问题,我们可以使用新建子进程来解决这个问题

    from multiprocessing import Process
    from  scrapy  import cmdline
    
    def execute_spider()
    	cmdline.execute('scrapy crawl my_spider'.split())
    
    my_pro = Process(target=executeSpider)
    my_pro.start()
    print("pid:%s  =" % my_pro.getpid())
    # 在这里可以获得pid,可以使用进程通信方式把pid传递过去,我比较简单,使用的文件存储pid,监控程序读文件就好了
    
    

    在这里使用getpid()便可以获得该爬虫的进程号,结合之前的命令,便可以知道当前程序是否正常运行。

    # 从tasklist的输出中,统计该pid的数量,从而判定该进程是否存在
     isAlive = os.popen('tasklist').read().count(pid) != 0
    

    3.2 Scrapy中间件之异常处理

    在Scrapy中存在两种中间件,一种是SpiderMiddleWare(蜘蛛中间件),一种是DownloaderMiddlerWare(下载器中间件)。

    • 蜘蛛中间件: Scrapy中Engine组件与Spider交互经过的中间件,如果蜘蛛发生的异常,就在这个里面处理,比如在解析数据的时候发生的错误。对应的方法如下:
     """
    response: 异常被抛出时被处理的response对象 
    exception: 抛出的异常 
    spider: 抛出该异常的spider对象 
    """ 
    def process_spider_exception(self, response, exception, spider): 
    	# 相应处理
    	pass
    
    • 下载器中间件:Scrapy中Engine组件与Downloader交互经过的中间件,这个处理的错误一般都是网络问题,或者服务器问题。与自己敲的蜘蛛代码关系不大。(我选的这个
    """ 
    request: 产生异常的request对象 
    exception: 抛出的异常对象 
    spider: 产生异常的request对象的spider对象 
    """ 
    def process_exception(self, request, exception, spider): 
    	# 相应处理
    	pass
    
    

    如果使用中间件,别忘记在setting.py文件中开启中间件

    DOWNLOADER_MIDDLEWARES = {
      'MySpider.middlewares.MyDownloaderMiddleware': 543,
    }
    

    or 蜘蛛中间件

    SPIDER_MIDDLEWARES = {
      'MySpider.middlewares.MySpiderMiddleware': 543,
    }
    

    4.相应处理

    现在已经知道进程是否正常、爬虫出错在哪处理。那么如何处理呢?

    4.1 继续运行

    第一种继续运行的方式,可以使用死循环,也可以使用调度任务。
    死循环实现比较简单,在同一个代码中,开启一个进程执行Scrapy爬虫,一个进程实现监控。(不推荐)

    #偷懒使用死循环的方式
     while True:
            p = os.popen('tasklist')
            pid = getPid() # 写个读文件的方法
            isAlive = p.read().count(pid) != 0
            count = count +1
            print( "%s  %s 次是 %s" %(datetime.datetime.now(),count,isAlive) )
            if(isAlive==False):
                my_pro = Process(target=executeSpider)
       			my_pro.start()
       			with open("pid.txt","w") as f:
       				f.write(my_pro.getpid())
            time.sleep(60)
    

    第二种利用中间件返回Request让爬虫继续执行:

     def process_exception(self, request, exception, spider): 
     with open("exceptionLog.txt", "a") as f:
                msg = "%s : %s\n" %(datetime.datetime.now(),exception)
                f.write(msg) #手动记录日志
     return request
    

    4.2 通知

    第一种使用窗口弹出,适合在电脑工作时跑的爬虫,这个窗口提醒会置顶,达到提醒的目的,同时程序也会阻塞,需要确认之后才会继续,当然如果有异常的话,也不需要继续了(不适合打游戏时开
    需要安装win32库: pip install pywin32

     win32api.MessageBox(0, "爬虫进程异常,请查看", "提醒", win32con.MB_SYSTEMMODAL)
    

    第二种使用邮件通知,适合不在电脑目前时跑的爬虫。
    (这个参考下一篇博文,封装一个发邮件的类,调用一下便ok。

    5. 总结

    使用一个工具需要慢慢的熟悉,第一个监控进程的方法是在没有弄清有两个中间件导致一直没找到解决方法所想的(囫囵吞枣学了一下Scapy。使用弹窗提醒还可以,同时也可以使用在其他可以在命令行所运行的程序上,见参考博客

    借鉴博客如下
    https://www.jb51.net/article/163273.htm
    https://blog.csdn.net/weixin_41990342/article/details/81907263

    展开全文
  • 主要介绍了Python如何自动获取目标网站最新通知,本文给大家分享实现思路及示例代码,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • hello 大家好,最近没有什么事,总结了一些关于python的算法题,希望能够帮到同学们! 最近总是听到一些朋友在BAT的面试经历,各种算法题让人脑瓜疼,如果没有提前准备的话,那就基本上只能回家等通知了,而今天要...

    hello 大家好,最近没有什么事,总结了一些关于python的算法题,希望能够帮到同学们!

    最近总是听到一些朋友在BAT的面试经历,各种算法题让人脑瓜疼,如果没有提前准备的话,那就基本上只能回家等通知了,而今天要跟大家说的这个二叉树DFS和BFS就是这些大型企业的必考题

    好了,那么接下来进行我们今天的话题,首先给大家展示一个二叉树,如下图

    二叉树定义:

    • 每个节点最多有两个子节点(子树)的树结构

    二叉树的遍历:

    • 深度优先遍历(DFS):沿着树的深度遍历结点,尽可能深的搜索树的分支。如果当前的节点所在的边都被搜索过,就回溯到当前节点所在的那条边的起始节点。一直重复直到进行到发现源节点所有可达的节点为止
    • 广度优先遍历(BFS):又称层次遍历,从树的根节点(root)开始,从上到下从从左到右遍历整个树的节点

    下面通过代码实现二叉树深度优先遍历(其实深度优先有两种方式) 先讲第一种栈的方式

    • 先定义Node类代表树的节点,Node节点有三个属性,节点存放的值value, 左子树lchild_tree, 右子树rchild_tree
    class Node(object):
        def __init__(self, value, lchild_tree=None, rchild_tree=None):
            self.value= value
            self.lchild_tree= lchild_tree
            self.rchild_tree= rchild_tree
    • 然后定义二叉树,与上面的二叉树图一样的结构,这里我们用变量的形式定义
    tree = Node(
        5,
        Node(
            3,
            Node(
                1,
                rchild_tree=Node(2)
            ),
            Node(4)
        ),
        Node(
            7,
            lchild_tree=Node(6)
        )
    )
    
    ​
    • 再定义一个深度优先遍历的方法
    def deep_visit(root):
        if not root: return
        stack = [root]
        while stack:
            current = stack.pop()
            print(current.value, end=",")
            if current.rchild_tree:
                stack.append(current.rchild_tree)
    
            if current.lchild_tree:
                stack.append(current.lchild_tree)

    这里需要解释一下了,我们将树传入deep_visit方法后,

    第一步:就是判断是否为空,这是非常必要的异步,如果为空直接返回

    第二步:用列表代替栈将树放入stack,这里我们把stack当做栈,此时stack只有一个节点那就是根节点root

    第三步:循环遍历stack,并且用pop方法删除最后一个元素,并返回删除的元素current,将其打印出来

    第四步:判断当前节点current的右子树是否为空,不为空则将current的右子树追加到stack中

    第五步:判断当前节点current的左子树是否为空,不为空则将右子树追加到stack中

    这里我解释下第二步为什么是栈:在遍历的时候,我们需要一个容器来装树的元素,因为是深度优先,我们在遍历的时候所经过的节点都需要被展示出来,并且是必须从根节点开始查找,所以顺序是 root(根节点)、左子树、右子树的顺序,因为栈的进出顺序是先进后出也是后进先出,所以当我们遍历到一个节点时应该先将右子树放进stack,然后再放左子树,这样我们下一次遍历时在栈最后的就是左子树了,也就可以用pop方法直接获取到左子树了

    最后就可以直接调用了

    deep_visit(tree)
    # 结果为:5,3,1,2,4,7,6,

    深度优先遍历第二种方式(递归的方式)

    • 节点Node的定义和数的变量就用上面的了,这里只要改造一下遍历deep_visit方法就可以,看代码
      def deep_visit(root):
          if not root: return
          print(root.value, end=',')
          deep_visit(root.lchild_tree)
          deep_visit(root.rchild_tree)

      第一步:还是先判断树是否为空,为空直接返回,不啰嗦

            第二步:打印当前节点的value

            第三步:以当前节点的左子树为参数调用当前方法deep_visit(root.lchild_tree)

            第四步:以当前节点的右子树为参数调用当前方法deep_visit(root.rchild_tree)

            这样就可以实现深度优先遍历了

    广度优先遍历

    • 节点Node的定义和数的变量都不变,这里只要改造一下遍历方法
    def wide_visit(root):
        if not root: return
        queue = [root]
        while queue:
            current = queue.pop(0)
            print(current.value, end=',')
            if current.lchild_tree:
                queue.append(current.lchild_tree)
            if current.rchild_tree:
                queue.append(current.rchild_tree)

         第一步:判断树是否为空

         第二步:这里就跟深度优先不同了,用的是队列,不过我们还是拿列表代替

         第三部:遍历queue队列,用pop(0)方法删除第一个元素,并返回当前被删掉的元素current,将current的value打印

         第四步:判断当前节点的左子树是否为空,不为空将左子树追加到queue中

         第五步:判断当前节点的右子树是否为空,不为空将右子树追加到queue中

         这里解释下为什么用队列了,因为是广度优先遍历是层级遍历,顺序为根节点、左节点、有节点,按层级从左到右遍历的

    ,由于队列的元素进出规律是先进先出,所以我们先将左节点放入队列再把右节点放入队列才符合广度优先遍历的特点

     

     

    如果有地方没看明白欢迎下方留言,大家相互学习,谢谢大家!

     

     

    展开全文
  • 单个工作单元独立于主应用程序线程运行,并通知调用线程其完成、失败情况或进度。下面这张图理解起来会更直观一些: 同步vs异步 同步编程很普遍。如图,请求1被发出后等待响应1;一旦得到响应1就发出请求2,...

    全文共2036字,预计学习时长6分钟

    图源:unsplash

     

    异步编程是并行编程的一种方式。单个工作单元独立于主应用程序线程运行,并通知调用线程其完成、失败情况或进度。下面这张图理解起来会更直观一些:

     

    同步vs异步

     

    同步编程很普遍。如图,请求1被发出后等待响应1;一旦得到响应1就发出请求2,然后等待它的响应。在上面的代码中,向函数传递参数“a”后等待函数返回更改后的值,然后再次调用以更改数字,最后再次得到响应,这就是同步编程。

     

    而对于异步编程来说,请求1被发出后,无需等响应1便可直接发出请求2。两个请求完成后得到两个响应。简单地说就是请求1和请求2是并行处理的,不等前一个请求的响应便提出新的请求。

     

    简言之,只要打开任务管理器(macOS中的活动监视器)就能看到多个应用程序同步运行;或者一个Python Shell在两个不同的终端窗口中运行。专业术语叫做多进程(MultiProcessing),顾名思义,即不止一个进程在运行。

     

    如何在Python中进行异步编程?

     

    一个同步编程的示例代码如下:


     

    deffun(length,a):
                      b = a
                      for i inrange(length):
                          a+=1
                      print("value of a before: "+str(b)+" now it's "+str(a))
                      return a
                     
                  defmain():
                      r1 =fun(50000000,0)
                      r2 =fun(100,12)
                      r3 =fun(100,41)
                  if __name__=="__main__":
                      main()

     

    以上代码的输出:

     

    这段代码传递了for循环的范围。执行代码耗时长达13.843秒,因为r1的范围是5000,所以耗时久。现在的问题是,必须先待r1任务完成,否则无法得到r2和r3。可能在得到r1之前就得到r2和r3吗?答案是肯定的,这正是异步编程的用武之地。

     

    首先用pip指令安装异步包。

     

    pip install asyncio

     

    安装后,看一下新代码。使用异步包:


     

    import asyncio
               asyncdeffun(length,a):
               b = a
               for i inrange(length):
                   a+=1
                   if i %10000==0:
                       await asyncio.sleep(0.0001)
                   print("value of a before: "+str(b)+" now it's "+str(a))
               return a
               asyncdefmain():
               #creating subroutines.
               t1 = loop.create_task(fun(50000000,0))
               t2 = loop.create_task(fun(100,12))
               t3 = loop.create_task(fun(100,41))
                   await asyncio.wait([t1,t2,t3])
               if __name__=="__main__":
               loop = asyncio.get_event_loop()
               loop.run_until_complete(main())
               loop.close()

     

    首先观察该代码的输出,接下来讨论该代码:

     

    输出-1

    输出-2

     

    输出-1中首先能得到t2和t3进程的结果,然后在输出-2的截图中得到了t1进程的结果,这是异步编程的功劳。t1进程耗时最长,所以它的结果最后产生,且t1、t2和t3进程均并行运行。异步编程的好处就在于不必等待任何进程的结果,便可获得下一个进程的结果。

     

    让我们讨论一下此代码。

     

    首先,在if __name__=="__main__"中定义了asyncio.get_event_loop(),并将这个循环作为处理循环事件的异步对象。然后创建一个main的例行程序,并设置条件:若main没完成则继续循环。每次异步,都要进行loop.close()的编程,否则结果就会错误或异常。

     

    然后将函数定义为asyncdeffunc_name,这样解释器就知道函数用了异步的方法。在main()中定义了三个任务(也可称为子例程),并使用了await函数,以便它等待三个进程结束(即使它没有多大意义,也必须使用它)。

     

    最后用了fun()函数。i %10000的if条件让最大范围的进程徐徐运行,最后得到了答案。仔细研究fun()函数并自己尝试的话,其中的逻辑会显得非常合理和直接。

     

    在Python中实现异步编程,你学会了吗?

     

    一起分享AI学习与发展的干货

    欢迎关注全平台AI垂类自媒体 “读芯术”

    (添加小编微信:dxsxbb,加入读者圈,一起讨论最新鲜的人工智能科技哦~)

    展开全文
  • 在本文中,我将引导您逐步编写如何使用Python获取桌面通知的程序。 桌面通知应用程序如何工作? 您今天将要学习开发的桌面通知应用程序的主要目的是不断提醒我们我们一天中需要完成的不同工作。 该任务类似于待办...
  • 如何Python实现微信按时发送文件

    千次阅读 2020-01-31 16:34:53
    如何Python实现微信按时发送文件自动修改Word微信自动发送文件主程序总结一下 回到单位,被通知要自行在家隔离15天,为了防疫大业必须严格按照要求约束自己。但是,不但单位需要每天按时上报情况,连儿子的小学也...
  • theading的Event使用的简单例子:###########... print "第一步:我在这里等你的通知 \n" # 当线程t调用start方法后,因为传递过来的Event对象在这里调用了wait()方法,所以线程会卡在这里 e.wait() print "第三步:
  • 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新 角色 抽象发布者:(Subject)具体发布者:(ConcreteSubject)抽象观察者:(Obeserver) 优点 1、观察者和...
  • Python如何发送邮件

    2019-08-01 19:41:26
    前言 今天我在构思软件的需求...邮件通知的应用除了通知,还有验证用户信息等等其他功能,接下来我们开始实现Python发送邮件 模板 import smtplib from email.mime.text import MIMEText from email.utils...
  • #如何在线程间进行事件通知 #实现一个打包线程,将转换出的xml文件压缩打包,比如转换线程每生产出100个xml文件, # 就通知打包线程将他们打包成一个xxx.tgz文件,并删除xml文件,打包完成后, # 打包线程反过来通知...
  • python 8-3 如何在线程间进行事件通知

    千次阅读 2017-01-28 17:30:43
    python 8-3-1 使用tarfile可以实现文件的压缩打包解决方案: 线程间的事件通知,可以使用标准库中的Threading.Event,如果是两个线程一般会用到2组eVent来相互通知 1.等待事件一端调用wait,等待事件 event.wait(),...
  • Python实现钉钉发送报警消息

    万次阅读 2017-05-13 22:10:26
    我司使用钉钉作为内部通讯工具,基本上大家在电脑和手机上都开着,消息可以第一时间查看,报警消息的即时性要求比较高,所以适合用钉钉通知。 本文介绍如何Python实现钉钉发送报警消息。
  • 下面介绍如何Python实现钉钉发送报警消息。 获取access token 要使用钉钉发送消息,首先需要获取access token,代码如下: def get_access_token(): url = '...
  • 1、使用定时任务执行脚本,检查主机存活信息2、将主机存活信息写入指定文件3、发现宕机的主机后给用户发邮件提醒备注:因为139邮箱在接受到邮件后会自动给用户发送条短信告知(且此服务免费),所以间接的实现了短信...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 125
精华内容 50
关键字:

python如何实现通知

python 订阅