精华内容
下载资源
问答
  • python中撤回上一步_python返回上一步

    千次阅读 2021-01-29 05:42:33
    Eclipse里编程代码,返回上一步的快捷键是alt+←箭头。 eclipse中几个最重要的快捷键。 代码助手:Ctrl+Space(简体中文操作系统是Alt+/)。 快速修正:Ctrl+1。 单词补全:Alt+/。 打开外部Java文档:Shift+F2。显示...

    python代码运行到某一步能返回到前面某一步吗?

    有。 Eclipse里编程代码,返回上一步的快捷键是alt+←箭头。 eclipse中几个最重要的快捷键。 代码助手:Ctrl+Space(简体中文操作系统是Alt+/)。 快速修正:Ctrl+1。 单词补全:Alt+/。 打开外部Java文档:Shift+F2。显示搜索对话框:Ctrl+H。

    python怎么把上一步得到的数值带到下一步中不用connect和send,直接sendto(addr, data)应该就不检测服务器有没有开。

    6bf53680d8efd61da090938c2e2a9442.png

    python 如何退回上级路径

    python 函数返回值返回到哪里

    python 函数返回值有两种形式: 1 返回一个值。 2 返回多个值。 现看看返回一个值的吧。 def firstvalue(a,b): c = a + b return c print firstvalue(1,2)结果:3 再看看返回多个值的: 那怎么可以返回多个值呢,其他的语言一般调用函数的话。

    在Eclipse里编程代码时,有返回到上一步的操作吗

    好像发帖人已经忘记这个问题了. 嗷, 没关系, 普及下eclipse撤销的快捷键: 返回分多种情况: 1. 看上一步编辑的代码(仅仅是看, 哪怕编辑框已关闭): 用Ctrl+q 2. 撤销上一步的代码(不但要看, 还要撤销修改, 对已关闭编辑框无效): 用Ctrl+z 3. 打开

    十万火急,Python新手提问,如何返回上一个值所在各位Python大师,这是我Excel表格里的文件,请看图片中所列出的示例,(也就是该值上一次出现所在的行数和列数? 该值是什么值? 你这描述太草率了

    python 的return为什么不能返回一个数值?

    def slice_apple(weight, time): if weight <= 1: return time else: we在输出结果的print语句上加一个判断就可以了。 def slice_apple(weight, time): if weight

    python中如何返回数值的绝对值

    如:-1或者1都返回1 。

    python中返回数值的绝对值的步骤如下: 1.第一步,定义一个变量a并调用abs()方法获取0的绝对值,返回对应的绝对值。 2.第二步,再次使用abs()方法获劝-230”的绝对值,负数的绝对值是相反数。 3.第三步,对正数获取绝对值,调用abs()方法。

    eclipse怎么执行上一步,下一步(撤销)的操作?

    Eclipse的相关使用操作如下: Eclipse的上一步操作快捷键为Ctrl+Z,即可将代码回退到最近一次的代码状态。 2.Eclipse的下一步操作快捷键为Ctrl+Y,这个快捷键与Ctrl+Z的组合是相反的。如果发现撤销上一步操作代码后不如原来的代码后。

    python中怎么返回指定查找字符的位置

    在一个长string中搜索某个字符串,比如搜索“test”,我用find只能返回第Python编程中对字符串进行搜索查找,并返回字符位置,案例代码如下: # multiple searches of a string for a substring # using s.find(sub[ ,start[, end]]) #以下面test这段文本为例text = 'MSKSASPKEPEQLRKLFIGGLSFETTDESLRSAHFESSSYGSAGRRF

    展开全文
  • 异步 IO 是一种并发编程设计,Python3.4 开始,已经有专门的标准库 asyncio 来支持异步 IO 操作。你可能会说,我知道并发用多线程,并行用多进程,这里面的知识已经够我掌握的了,异步 IO 又是个什么鬼?本文将会...

    异步 IO 是一种并发编程设计,Python3.4 开始,已经有专门的标准库 asyncio 来支持异步 IO 操作。你可能会说,我知道并发用多线程,并行用多进程,这里面的知识已经够我掌握的了,异步 IO 又是个什么鬼?本文将会回答该问题,从而使你更加牢固地掌握 Python 的异步 IO 操作方法。

    几个名词先解释下:异步:异步是什么意思?这不是一个严格的定义,从下面两个方面来理解:异步程序可以在等待其最终结果的同时“暂停”并让其他程序同时运行。

    通过上述机制,异步代码有助于并发执行。换句话说,异步代码表现出了并发的特点。

    异步IO:一种与语言无关的范例(模型) ,很多编程语言都有这种实现,它是一种单线程,单进程设计:它使用协作多任务处理,尽管在单个进程中使用单个线程,异步 IO 仍具有并发的感觉。async/await:两个用于定义协程的新 Python 关键字。asyncio:Python 标准库,为运行和管理协程提供了基础和 API。

    1、同步和异步的区别:

    假设你去参加象棋比赛,有以下条件:24 个对手

    在 5 秒内使每盘棋移动

    对手各花费 55 秒采取行动

    游戏平均 30 对动作(总共 60 个动作)

    同步:你一次只能和一个对手下棋,在一局比赛结束前不能进入下一个。每个游戏需要(55 + 5) x 30 == 1800 秒或 30 分钟。整个展览需要 24 * 30 == 720 分钟或 12 个小时。异步:你在棋盘之间移动,在每个棋盘上移动一步,离开桌子,让对手在等待时间内和另一个对手下棋。在所有 24 场比赛中,一动需要 24 x 5 == 120 秒或 2 分钟。现在整个展览减少到 120 x 30 == 3600 秒,或仅 1 小时你只有两只手,一次只能移动一步。但是异步的方法可以从 12 小时减少到 1 小时。因此,协作式多任务处理是一种奇特的方式,可以说程序的事件循环与多个任务进行通信,以使每个任务在最佳时间轮流运行。

    2、异步并不简单

    网上流传这样的话:当必须使用多线程时就使用多线程,否则都尽可能使用异步 IO 。构建健壮的多线程程序是困难的且容易出错,异步 IO 避免了线程设计可能会遇到的某些潜在速度瓶颈。这并不是说写异步 IO 代码是简单的,请注意:当你进入底层时,异步编程也可能会很困难!Python 的异步模型是基于诸如回调,事件,传输,协议和期程( futures ) 之类的概念构建的,这些术语可能令人生畏。幸运的是,asyncio 已经发展的非常成熟,它的大多数功能不再是临时的,文档已得到了巨大的改进,与此相关的一些优质资源也开始出现。

    3、async/await 语法及协程

    异步 IO 的核心是协程。协程是一种特殊的 Python 函数,可以在到达返回值之前暂停其执行,并且可以将控制权间接传递给另一个协程一段时间。了解协程最简单的方法就是写一个 hello world 的代码来感受一下:

    #!/usr/bin/env python3

    # countasync.py

    import asyncio

    async def count() :

    print("One")

    await asyncio.sleep(1)

    print("Two")

    async def main() :

    await asyncio.gather(count() , count() , count())

    if __name__ == "__main__":

    import time

    s = time.perf_counter()

    asyncio.run(main())

    elapsed = time.perf_counter() - s

    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

    执行结果:

    One

    One

    One

    Two

    Two

    Two

    e:\countasync.py executed in 1.01 seconds.

    这里使用 time.sleep() 和 asyncio.sleep() 是有区别的,time.sleep() 可以表示任何耗时的阻塞函数调用,而 asyncio.sleep 不阻塞,可将 CPU 的控制权交给下一个协程。

    4、Async IO 的规则

    理解了 async,await 的规则,对掌握异步/等待功能非常重要。关键字 async def 可以定义一个协程函数或一个异步生成器函数。关键字 await 将功能控制传回事件循环。比如:

    async def g() :

    # Pause here and come back to g() when f() is ready

    r = await f()

    return r

    这里的 await 挂起了本次协程的执行。如果 Python 在 g() 范围内遇到 await f() 表达式,那就意味着,“暂停 g() 的执行,直到我等待f() 返回结果。同时,让其他协程运行。”。当然也有一些规则要求什么地方可以使用 async/await 关键字,什么地方不能用:使用 async def 定义的函数是一个协程,它内部可以使用 await,return,yield,也可以都不用。使用 wait 或 return 创建一个coroutine函数。要调用 coroutine 函数,你必须使用 await 关键字。

    很少情况下会在 async del 的代码块中使用 yield ,如果用了,会产生一个异步的生成器。

    任何 async def 内都不能使用 yield from,会抛出语法错误。

    就像不能在函数外面使用 yield 一样,也不能在 async def 外使用 await。会抛出语法错误。

    下面是一些例子:

    async def f(x) :

    y = await z(x) # OK - `await` and `return` allowed in coroutines

    return y

    async def g(x) :

    yield x # OK - this is an async generator

    async def m(x) :

    yield from gen(x) # No - SyntaxError

    def m(x) :

    y = await z(x) # Still no - SyntaxError (no `async def` here)

    return y

    言归正传,让我们来看一个更复杂的例子:给定一个产生随机数的函数 makerandom,它产生一个 0-9 之间的随机数,直到超过给定数据后结束,让此协程的多个调用无需等待彼此即可执行,代码如下:

    import asyncio

    import random

    # ANSI colors

    c = (

    "\033[0m", # End of color

    "\033[36m", # Cyan

    "\033[91m", # Red

    "\033[35m", # Magenta

    )

    async def makerandom(idx: int, threshold: int = 6) -> int:

    print(c[idx + 1] + f"Initiated makerandom({idx}) .")

    i = random.randint(0, 10)

    while i <= threshold:

    print(c[idx + 1] + f"makerandom({idx}) == {i} too low; retrying.")

    await asyncio.sleep(idx + 1)

    i = random.randint(0, 10)

    print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])

    return i

    async def main() :

    res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)) )

    return res

    if __name__ == "__main__":

    random.seed(444)

    r1, r2, r3 = asyncio.run(main())

    print()

    print(f"r1: {r1}, r2: {r2}, r3: {r3}")

    运行结果如下:

    该程序使用一个主协程 makerandom() ,并在 3 个不同的输入上同时运行它。大多数程序将包含小型模块化协程和一个包装器功能,用于将每个较小的协程链接在一起。main() 通过在一些可迭代或池中映射中央协程来收集任务。在此示例中,池为 range(3) 。尽管“制作随机整数”(比CPU绑定更多的东西) 可能不是 asyncio 的最佳选择,但在示例中正是 asyncio.sleep() 旨在模仿 IO 绑定的过程等待时间不确定的地方。例如,asyncio.sleep() 调用可以表示在消息应用程序的两个客户端之间发送和接收的延迟。

    5、异步 IO 设计模式

    异步 IO 的设计模式,分为以下两种:

    链式协程

    协程的一个关键特征是它们可以链接在一起。请记住,一个协程对象是可以 await 的,因此另一个协程可以等待它。利用这一点可以将程序分解为较小的,可管理的,可回收的协程:

    #!/usr/bin/env python3

    # chained.py

    import asyncio

    import random

    import time

    async def part1(n: int) -> str:

    i = random.randint(0, 10)

    print(f"part1({n}) sleeping for {i} seconds.")

    await asyncio.sleep(i)

    result = f"result{n}-1"

    print(f"Returning part1({n}) == {result}.")

    return result

    async def part2(n: int, arg: str) -> str:

    i = random.randint(0, 10)

    print(f"part2{n, arg} sleeping for {i} seconds.")

    await asyncio.sleep(i)

    result = f"result{n}-2 derived from {arg}"

    print(f"Returning part2{n, arg} == {result}.")

    return result

    async def chain(n: int) -> None:

    start = time.perf_counter()

    p1 = await part1(n)

    p2 = await part2(n, p1)

    end = time.perf_counter() - start

    print(f"-->Chained result{n} => {p2} (took {end:0.2f} seconds) .")

    async def main(*args) :

    await asyncio.gather(*(chain(n) for n in args))

    if __name__ == "__main__":

    import sys

    random.seed(444)

    args = [1, 2, 3] if len(sys.argv) == 1 else map(int, sys.argv[1:])

    start = time.perf_counter()

    asyncio.run(main(*args))

    end = time.perf_counter() - start

    print(f"Program finished in {end:0.2f} seconds.")

    注意观察输出,part1() 睡眠一段时间,part2() 在结果可用时开始处理它们:

    $ python3 chained.py 9 6 3

    part1(9) sleeping for 4 seconds.

    part1(6) sleeping for 4 seconds.

    part1(3) sleeping for 0 seconds.

    Returning part1(3) == result3-1.

    part2(3, 'result3-1') sleeping for 4 seconds.

    Returning part1(9) == result9-1.

    part2(9, 'result9-1') sleeping for 7 seconds.

    Returning part1(6) == result6-1.

    part2(6, 'result6-1') sleeping for 4 seconds.

    Returning part2(3, 'result3-1') == result3-2 derived from result3-1.

    -->Chained result3 => result3-2 derived from result3-1 (took 4.00 seconds) .

    Returning part2(6, 'result6-1') == result6-2 derived from result6-1.

    -->Chained result6 => result6-2 derived from result6-1 (took 8.01 seconds) .

    Returning part2(9, 'result9-1') == result9-2 derived from result9-1.

    -->Chained result9 => result9-2 derived from result9-1 (took 11.01 seconds) .

    Program finished in 11.01 seconds.

    在以上代码中,main() 的运行时间将等于它收集在一起的协程任务的最大运行时间。

    使用队列

    asyncio.Queue 类在与标准库 queue 的功能相似。前述示例中,并不需要队列结构。在 chained.py 中,每个任务都由一组协程组成,这些协程明确地相互等待,并在每个链中传递单个输入。还有一种可以与异步 IO 一起使用的数据结构:许多彼此不相关的生产者将项目添加到队列中。每个生产者可以在交错、随机、未通知的时间将多个项目添加到队列中。一群消费者将它们从队列中拉出,而不必等待任何其他信号。在这种设计中,没有任何消费者链接到生产者。消费者不知道生产者的数量,甚至不知道将要添加到队列中的项目的累计数量。每个生产者或消费者花费可变的时间分别从队列中放入和提取项目。队列充当可以与生产者和消费者进行通信的桥梁,而无需他们直接相互交谈。下面是示例代码 asyncq.py。该工作流程中具有挑战性的部分是,需要向消费者发出生产已经完成的信号。否则,await q.get() 会无限期挂起,因为队列已被完全处理,但是消费者不会知道生产已经完成。main 函数中的 q.join,该操作将阻塞直到队列中的所有项目都已接收并处理,否则将挂断并无休止地等待其他队列项目出现。

    #!/usr/bin/env python3

    # asyncq.py

    import asyncio

    import itertools as it

    import os

    import random

    import time

    async def makeitem(size: int = 5) -> str:

    return os.urandom(size) .hex()

    async def randsleep(a: int = 1, b: int = 5, caller=None) -> None:

    i = random.randint(0, 10)

    if caller:

    print(f"{caller} sleeping for {i} seconds.")

    await asyncio.sleep(i)

    async def produce(name: int, q: asyncio.Queue) -> None:

    n = random.randint(0, 10)

    for _ in it.repeat(None, n) : # Synchronous loop for each single producer

    await randsleep(caller=f"Producer {name}")

    i = await makeitem()

    t = time.perf_counter()

    await q.put((i, t))

    print(f"Producer {name} added <{i}> to queue.")

    async def consume(name: int, q: asyncio.Queue) -> None:

    while True:

    await randsleep(caller=f"Consumer {name}")

    i, t = await q.get()

    now = time.perf_counter()

    print(f"Consumer {name} got element <{i}>"

    f" in {now-t:0.5f} seconds.")

    q.task_done()

    async def main(nprod: int, ncon: int) :

    q = asyncio.Queue()

    producers = [asyncio.create_task(produce(n, q)) for n in range(nprod) ]

    consumers = [asyncio.create_task(consume(n, q)) for n in range(ncon) ]

    await asyncio.gather(*producers)

    await q.join() # Implicitly awaits consumers, too

    for c in consumers:

    c.cancel()

    if __name__ == "__main__":

    import argparse

    random.seed(444)

    parser = argparse.ArgumentParser()

    parser.add_argument("-p", "--nprod", type=int, default=5)

    parser.add_argument("-c", "--ncon", type=int, default=10)

    ns = parser.parse_args()

    start = time.perf_counter()

    asyncio.run(main(**ns.__dict__))

    elapsed = time.perf_counter() - start

    print(f"Program completed in {elapsed:0.5f} seconds.")

    第一个协程是辅助函数,它们返回一个随机字符串。生产者将 1 到 5 个项目放入队列中。每个项目都是(i,t) 的元组,其中 i 是随机字符串,t 是生产者尝试将元组放入队列的时间。消费者将商品拉出时,它仅使用放入商品的时间戳来计算商品在队列中的经过时间。请记住,asyncio.sleep() 用于模仿其他一些更复杂的协程,如果这是常规的阻止函数,则会消耗时间并阻止所有其他执行。这是由两个生产者和五个消费者进行的测试结果:

    $ python3 asyncq.py -p 2 -c 5

    Producer 0 sleeping for 3 seconds.

    Producer 1 sleeping for 3 seconds.

    Consumer 0 sleeping for 4 seconds.

    Consumer 1 sleeping for 3 seconds.

    Consumer 2 sleeping for 3 seconds.

    Consumer 3 sleeping for 5 seconds.

    Consumer 4 sleeping for 4 seconds.

    Producer 0 added <377b1e8f82> to queue.

    Producer 0 sleeping for 5 seconds.

    Producer 1 added <413b8802f8> to queue.

    Consumer 1 got element <377b1e8f82> in 0.00013 seconds.

    Consumer 1 sleeping for 3 seconds.

    Consumer 2 got element <413b8802f8> in 0.00009 seconds.

    Consumer 2 sleeping for 4 seconds.

    Producer 0 added <06c055b3ab> to queue.

    Producer 0 sleeping for 1 seconds.

    Consumer 0 got element <06c055b3ab> in 0.00021 seconds.

    Consumer 0 sleeping for 4 seconds.

    Producer 0 added <17a8613276> to queue.

    Consumer 4 got element <17a8613276> in 0.00022 seconds.

    Consumer 4 sleeping for 5 seconds.

    Program completed in 9.00954 seconds.

    在这种情况下,生产或消费的每一个处理过程将在几分之一秒内完成处理。延迟可能有两个原因:标准开销,在很大程度上是不可避免的开销

    队列中时所有消费者都在睡觉的情况

    关于第二点原因,扩展到成百上千的消费者是完全正常的。python3 asyncq.py -p 5 -c 100 应该没有问题。从理论上讲,你可以在不同的系统上使用不同的用户来控制生产者和消费者的管理,而队列则作为中间桥梁。

    6、一个完整的异步 http 请求

    接下来将使用 aiohttp (一种非常快的异步 HTTP 客户端/服务器框架) 来构建可抓取网址的 URL 爬虫程序 areq.py。这样的工具可用于映射站点集群之间的连接,链接形成有向图。你可能想知道为什么 Python 的 requests 库与异步 IO 不兼容,原因是 requests 库建立在 urllib3 之上,而 urllib3 又使用 Python 的 http 和套接字模块, 默认情况下,套接字操作处于阻塞状态。这意味着 Python 不会使用 await request.get(url) ,因为 get() 无法等待。相反,aiohttp 中的几乎所有内容都是可等待的协程,例如 session.request() 和 response.text()。一个高级别的程序结构应该是这样的:从一个本地文件 urls.txt 中读取一系列 URLs。

    对 1 中的 URL 发送 GET 请求,并解码返回的结果,如果这一步失败,就停止对此 URL 操作。

    在 2 的结果中查找超链接,并将超链接信息保存在 foundurls.txt 中

    尽可能使用并发异步操作执行以上过程。使用 aiohttp 进行网络请求,aiofiles 操作文件。

    url.txt 的内容如下:

    $ cat urls.txt

    https://regex101.com/

    https://docs.python.org/3/this-url-will-404.html

    https://www.nytimes.com/guides/

    https://www.mediamatters.org/

    https://1.1.1.1/

    https://www.politico.com/tipsheets/morning-money

    https://www.bloomberg.com/markets/economics

    https://www.ietf.org/rfc/rfc2616.txt

    列表中的第二个 URL 应该返回 404 响应,你需要对其进行适当处理。在实际使用中,可能需要处理比这更棘手的问题,例如服务器断开连接和无止尽的重定向。请求本身应使用单个会话发出,以充分利用会话的内部连接池。让我们看一下完整的程序:

    #!/usr/bin/env python3

    # areq.py

    """Asynchronously get links embedded in multiple pages' HMTL."""

    import asyncio

    import logging

    import re

    import sys

    from typing import IO

    import urllib.error

    import urllib.parse

    import aiofiles

    import aiohttp

    from aiohttp import ClientSession

    logging.basicConfig(

    format="%(asctime) s %(levelname) s:%(name) s: %(message) s",

    level=logging.DEBUG,

    datefmt="%H:%M:%S",

    stream=sys.stderr,

    )

    logger = logging.getLogger("areq")

    logging.getLogger("chardet.charsetprober") .disabled = True

    HREF_RE = re.compile(r'href="(.*?) "')

    async def fetch_html(url: str, session: ClientSession, **kwargs) -> str:

    """GET request wrapper to fetch page HTML.

    kwargs are passed to `session.request() `.

    """

    resp = await session.request(method="GET", url=url, **kwargs)

    resp.raise_for_status()

    logger.info("Got response [%s] for URL: %s", resp.status, url)

    html = await resp.text()

    return html

    async def parse(url: str, session: ClientSession, **kwargs) -> set:

    """Find HREFs in the HTML of `url`."""

    found = set()

    try:

    html = await fetch_html(url=url, session=session, **kwargs)

    except (

    aiohttp.ClientError,

    aiohttp.http_exceptions.HttpProcessingError,

    ) as e:

    logger.error(

    "aiohttp exception for %s [%s]: %s",

    url,

    getattr(e, "status", None) ,

    getattr(e, "message", None) ,

    )

    return found

    except Exception as e:

    logger.exception(

    "Non-aiohttp exception occured: %s", getattr(e, "__dict__", {})

    )

    return found

    else:

    for link in HREF_RE.findall(html) :

    try:

    abslink = urllib.parse.urljoin(url, link)

    except (urllib.error.URLError, ValueError) :

    logger.exception("Error parsing URL: %s", link)

    pass

    else:

    found.add(abslink)

    logger.info("Found %d links for %s", len(found) , url)

    return found

    async def write_one(file: IO, url: str, **kwargs) -> None:

    """Write the found HREFs from `url` to `file`."""

    res = await parse(url=url, **kwargs)

    if not res:

    return None

    async with aiofiles.open(file, "a") as f:

    for p in res:

    await f.write(f"{url}\t{p}\n")

    logger.info("Wrote results for source URL: %s", url)

    async def bulk_crawl_and_write(file: IO, urls: set, **kwargs) -> None:

    """Crawl & write concurrently to `file` for multiple `urls`."""

    async with ClientSession() as session:

    tasks = []

    for url in urls:

    tasks.append(

    write_one(file=file, url=url, session=session, **kwargs)

    )

    await asyncio.gather(*tasks)

    if __name__ == "__main__":

    import pathlib

    import sys

    assert sys.version_info >= (3, 7) , "Script requires Python 3.7+."

    here = pathlib.Path(__file__) .parent

    with open(here.joinpath("urls.txt")) as infile:

    urls = set(map(str.strip, infile))

    outpath = here.joinpath("foundurls.txt")

    with open(outpath, "w") as outfile:

    outfile.write("source_url\tparsed_url\n")

    asyncio.run(bulk_crawl_and_write(file=outpath, urls=urls))

    $ python3 areq.py

    21:33:22 DEBUG:asyncio: Using selector: KqueueSelector

    21:33:22 INFO:areq: Got response [200] for URL: https://www.mediamatters.org/

    21:33:22 INFO:areq: Found 115 links for https://www.mediamatters.org/

    21:33:22 INFO:areq: Got response [200] for URL: https://www.nytimes.com/guides/

    21:33:22 INFO:areq: Got response [200] for URL: https://www.politico.com/tipsheets/morning-money

    21:33:22 INFO:areq: Got response [200] for URL: https://www.ietf.org/rfc/rfc2616.txt

    21:33:22 ERROR:areq: aiohttp exception for https://docs.python.org/3/this-url-will-404.html [404]: Not Found

    21:33:22 INFO:areq: Found 120 links for https://www.nytimes.com/guides/

    21:33:22 INFO:areq: Found 143 links for https://www.politico.com/tipsheets/morning-money

    21:33:22 INFO:areq: Wrote results for source URL: https://www.mediamatters.org/

    21:33:22 INFO:areq: Found 0 links for https://www.ietf.org/rfc/rfc2616.txt

    21:33:22 INFO:areq: Got response [200] for URL: https://1.1.1.1/

    21:33:22 INFO:areq: Wrote results for source URL: https://www.nytimes.com/guides/

    21:33:22 INFO:areq: Wrote results for source URL: https://www.politico.com/tipsheets/morning-money

    21:33:22 INFO:areq: Got response [200] for URL: https://www.bloomberg.com/markets/economics

    21:33:22 INFO:areq: Found 3 links for https://www.bloomberg.com/markets/economics

    21:33:22 INFO:areq: Wrote results for source URL: https://www.bloomberg.com/markets/economics

    21:33:23 INFO:areq: Found 36 links for https://1.1.1.1/

    21:33:23 INFO:areq: Got response [200] for URL: https://regex101.com/

    21:33:23 INFO:areq: Found 23 links for https://regex101.com/

    21:33:23 INFO:areq: Wrote results for source URL: https://regex101.com/

    21:33:23 INFO:areq: Wrote results for source URL: https://1.1.1.1/

    7、其他高级异步函数

    除了 asyncio.run() 之外,你还看到了其他一些函数,例如 asyncio.create_task() 和 asyncio.gather() 。你可以使用 create_task() 安排协程对象的执行,然后使用 asyncio.run() :

    >>> import asyncio

    >>> async def coro(seq) -> list:

    ... """'IO' wait time is proportional to the max element."""

    ... await asyncio.sleep(max(seq))

    ... return list(reversed(seq))

    ...

    >>> async def main():

    ... # This is a bit redundant in the case of one task

    ... # We could use `await coro([3, 2, 1])` on its own

    ... t = asyncio.create_task(coro([3, 2, 1])) # Python 3.7+

    ... await t

    ... print(f't: type {type(t)}')

    ... print(f't done: {t.done()}')

    ...

    >>> t = asyncio.run(main())

    t: type

    t done: True

    如果不在 main() 中使用 await ,它可能会在 main() 本身完成之前就结束了。因为 asyncio.run(main()) 调用 loop.run_until_complete(main()) ,所以事件循环仅关注 main() 完成,而不关注在 main() 中创建的任务是否完成。如果不等待,循环的其他任务可能会在完成之前被取消。如果需要获取当前待处理任务的列表,则可以使用 asyncio.Task.all_tasks() 。另外,还有 asyncio.gather() 。尽管它没有做任何特别的事情,但是 collect() 的目的是将协程的集合整齐地放在一个 future。结果,它返回一个 future 的对象,如果你等待 asyncio.gather() 并指定多个任务或协程,则你正在等待所有这些任务或协程完成。这与我们前面的示例有点类似 queue.join() ,collect() 的结果将是输入结果的列表:

    >>> import time

    >>> async def main():

    ... t = asyncio.create_task(coro([3, 2, 1]))

    ... t2 = asyncio.create_task(coro([10, 5, 0])) # Python 3.7+

    ... print('Start:', time.strftime('%X'))

    ... a = await asyncio.gather(t, t2)

    ... print('End:', time.strftime('%X')) # Should be 10 seconds

    ... print(f'Both tasks done: {all((t.done(), t2.done()))}')

    ... return a

    ...

    >>> a = asyncio.run(main())

    Start: 16:20:11

    End: 16:20:21

    Both tasks done: True

    >>> a

    [[1, 2, 3], [0, 5, 10]]

    你可能已经注意到,collect() 等待传递给它的 Future 或协程的整个结果集。你可以遍历 asyncio.as_completed() 以按完成顺序获取任务结果。该函数返回一个迭代器,该迭代器在完成任务时产生任务。下面,在coro([10,5,0]) 完成之前,可使用coro([3,2,1]) 的结果,而用 collect() 则不是这样:

    >>> async def main():

    ... t = asyncio.create_task(coro([3, 2, 1]))

    ... t2 = asyncio.create_task(coro([10, 5, 0]))

    ... print('Start:', time.strftime('%X'))

    ... for res in asyncio.as_completed((t, t2)):

    ... compl = await res

    ... print(f'res: {compl} completed at {time.strftime("%X")}')

    ... print('End:', time.strftime('%X'))

    ... print(f'Both tasks done: {all((t.done(), t2.done()))}')

    ...

    >>> a = asyncio.run(main())

    Start: 09:49:07

    res: [1, 2, 3] completed at 09:49:10

    res: [0, 5, 10] completed at 09:49:17

    End: 09:49:17

    Both tasks done: True

    8、异步无头浏览器 pyppeteer

    pyppeteer 模块,它是无头浏览器 Puppeteer 的 Python 移植,API 跟 JavaScript 版本基本一致。下面是安装命令。

    #!/usr/bin/env python3

    # screenshot.py

    import asyncio

    from pyppeteer import launch

    async def main():

    browser = await launch()

    page = await browser.newPage()

    await page.goto('http://example.com')

    await page.screenshot({'path': 'example.png'})

    await browser.close()

    asyncio.run(main())

    上面代码中,启动浏览器、打开新 Tab、访问网址、截图、关闭浏览器,这一系列操作都是异步任务,使用 await 命令写起来非常自然简单。执行这个脚本,当前目录下就会生成截图文件 example.png。如果脚本执行时报错 No usable sandbox!,可以参考这里。另外,第一次执行这个脚本,会下载安装 Puppeteer,可能需要等待较长时间,但是此后的执行就会很快。Pyppeteer 的官网还有其他实例,比如向网页注入 JavaScript 代码。

    展开全文
  • 今天小编就来教一教大家返回上一步的快捷键,想知道的赶快来看一看小编下面编写的这些步骤吧。工具/原料电脑 Windows7键盘 极影2.0方法/步骤1首先大家打开我们的电脑,在电脑上随便打开一个页面,开始编辑内容,再...

    今天小编就来教一教大家返回上一步的快捷键,想知道的赶快来看一看小编下面编写的这些步骤吧。

    工具/原料

    电脑 Windows7

    键盘 极影2.0

    方法/步骤

    1

    首先大家打开我们的电脑,在电脑上随便打开一个页面,开始编辑内容,再进行下一步操作。

    3b8fb4d7726b0ce2e8b665bbef781423bfb9b6e5.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    2

    帮大家编辑到一半,一不小心删除了一些内容,有想要把删除的那一部分给找回来的时候。

    777f3fc2bbd6e1d0fbb9cbd50d254193cfe8afe5.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    3

    那么大家就需要在键盘上找到“Alt”和“Z”这两个键,如下图所示。再进行下面的操作。

    555acf0ff2260d9a915f462d622abab84340a5e5.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    4

    最后大家先按住“Alt”键,再快速的按住“Z”这两个键这样操作后就会会返回到上一步,那么上一步误删的内容就会又出现。

    430174fec314f1c53dbf10753c27ac5307889de5.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    END

    总结:

    1

    1.打开电脑编辑内容,一不小心误删刚刚的内容。

    2.在键盘上找到“Alt”和“Z”这两个键。

    3.先按住“Alt”键,再快速的按住“Z”即可。

    END

    注意事项

    返回到上一步的键是“Alt+Z”。

    希望对大家有帮助。

    经验内容仅供参考,如果您需解决具体问题(尤其法律、医学等领域),建议您详细咨询相关领域专业人士。

    展开阅读全部

    展开全文
  • 工欲善其事,必先利其器。所以第一步,我们先下载第三方库。在这里,我用到的是pymysql库。下载库:在命令行输入1pip install pymysql...python2Python 3.6.3 |Anaconda, Inc.| (default, Oct 15 2017, 03:27:45) [...

    工欲善其事,必先利其器。所以第一步,我们先下载第三方库。在这里,我用到的是pymysql库。

    下载库:在命令行输入

    1pip install pymysql

    下载后可检验一下是否成功下载。直接在命令行进入python然后导库即可

    1C:\Users\June>python

    2Python 3.6.3 |Anaconda, Inc.| (default, Oct 15 2017, 03:27:45) [MSC v.1900 64 bit (AMD64)] on win32

    3Type "help", "copyright", "credits" or "license" for more information.

    4>>> import pymysql

    5>>>

    看到这个画面就说明下载成功了,接下来学习如何操作数据库了!!!

    连接数据库

    1import pymysql

    2# 连接数据库

    3db = pymysql.connect(host='127.0.0.1',user='root',passwd='your password',db='news',port=3306,charset='utf8')

    以上的参数是必填的

    host: 这个是ip地址,因为我这里是本地的,所以填127.0.0.1,也可以填localhost。

    user:用户名,如果你也是本地的,就填root好了

    passwd:这个是密码,填上你自己设的密码就可以了

    db:这个是数据库名,我这里选的是news数据库

    port:这个是端口,本地的一般都是3306

    charset:这个是编码方式,要和你数据库的编码方式一致,要不会连接失败

    连接上了,怎么验证呢?这里我们可以选择查一条数据

    1try:

    2 db = pymysql.connect(host='127.0.0.1',user='root',passwd='your password',db='news',port=3306,charset='utf8')

    3 # 检验数据库是否连接成功

    4 cursor = db.cursor()

    5 # 这个是执行sql语句,返回的是影响的条数

    6 data = cursor.execute('SELECT * FROM `new`')

    7 # 得到一条数据

    8 one = cursor.fetchone()

    9 print(data)

    10 print(one)

    11except pymysql.Error as e:

    12 print(e)

    13 print('操作数据库失败')

    14finally:

    15 # 如果连接成功就要关闭数据库

    16 if db:

    17 db.close()

    代码解读:因为在连接数据库中,有时会发生连接失败等异常,所以这里就进行捕捉异常,这里的异常都是在 pymsql.Error里面。上面的代码看不懂也没关系,因为我接下来会说,如果运行后有结果证明连接成功。

    在用完后,一定要记得关闭数据库连接,防止资源泄露问题。

    对数据进行查询

    1import pymysql

    2try:

    3 conn = pymysql.connect(host='127.0.0.1',user='root',passwd='password',db='news',charset='utf8',port=3306)

    4 # 这个是光标,用来操作数据库语句

    5 cursor = conn.cursor()

    6 # 执行sql语句

    7 cursor.execute('SELECT * FROM `new`')

    8 print(cursor.fetchone())

    9 # 关闭光标

    10 cursor.close()

    11except pymysql.Error as e:

    12 print(e)

    13 print('操作数据库失败')

    14finally:

    15 if conn:

    16 conn.close()

    代码解读:cursor():这个是光标,用来执行mysql语句的,用完后也是需要关闭的

    excute():这个是执行语句,执行参数的mysql语句

    fetchone():这个是查看执行语句后的一条数据

    fetchall():这个是查看所有数据

    在查询数据后,返回的是一整条数据,有没有可以按字典形式来查询的呢?来试试!

    1print(cursor.fetchone()['name'])

    2

    3Traceback (most recent call last):

    4 File "E:/anaconda/python_project/mysql_test/test2.py", line 8, in

    5 print(cursor.fetchone()['name'])

    6TypeError: tuple indices must be integers or slices, not str

    查了之后,编译器想都不想就给了我这个错误,说这是个元组,不能这样操作。

    虽然python没有提供,但是我们可以手动转成字典来查询啊

    cursor这里有个属性:description。获取的是数据库每个栏位情况,如下:

    1print(cursor.description)

    2# 下面是结果

    3(('id', 3, None, 11, 11, 0, False), ('type', 253, None, 5, 5, 0, False), ('title', 253, None, 50, 50, 0, False), ('content', 253, None, 2000, 2000, 0, False), ('view_count', 3, None, 11, 11, 0, False), ('release_time', 12, None, 19, 19, 0, False), ('author', 253, None, 20, 20, 0, True), ('from', 253, None, 20, 20, 0, True), ('is_valibale', 3, None, 11, 11, 0, False)

    所以,我们利用这个属性手动生成字典

    1# 将一条数据转成字典方便查找

    2new = dict(zip([x[0] for x in cursor.description],[x for x in cursor.fetchone()]))

    3print(new)

    4# 下面是结果

    5{'id': 2, 'type': 'NBA', 'title': '考辛斯跟腱撕裂赛季报销 浓眉詹皇发声祝福', 'content': '他遭遇左脚跟腱撕裂,将缺席赛季剩下的比赛。这无疑对考辛斯和鹈鹕队都是一个重大的打击', 'view_count': 3560, 'release_time': datetime.datetime(2018, 1, 27, 12, 10), 'author': 'xiaoylin', 'from': '腾讯体育', 'is_valibale': 1}

    这里利用zip函数和列表生成式来一行代码就生成成功了

    用字典来查询,现在就可以了

    1print(new['title'])

    2# 下面是结果

    3考辛斯跟腱撕裂赛季报销 浓眉詹皇发声祝福

    但是,上面的只是一条数据的,如果是多条的呢?再按上面的方法就行不通了。这时就需要用到map函数了

    1def new2dict(new):

    2 return dict(zip([x[0] for x in cursor.description],[x for x in new]))

    3news_list = list(map(new2dict,cursor.fetchall()))

    4print(news_list)

    5# 下面是结果

    6[{'id': 2, 'type': 'NBA', 'title': '考辛斯跟腱撕裂赛季报销 浓眉詹皇发声祝福', 'content': '他遭遇左脚跟腱撕裂,将缺席赛季剩下的比赛。这无疑对考辛斯和鹈鹕队都是一个重大的打击', 'view_count': 3560, 'release_time': datetime.datetime(2018, 1, 27, 12, 10), 'author': 'xiaoylin', 'from': '腾讯体育', 'is_valibale': 1}, {'id': 3, 'type': 'NBA', 'title': '火箭挖21分大哈登得背锅 连遭浓眉大帽太尴尬', 'content': '火箭在客场以113-115惜败于鹈鹕,4连胜终结。詹姆斯-哈登出战34分钟16投5中,其中三分球9投只有1中,罚球14罚12中,拿到23分、11助攻、5篮板但也有4次失误,其在场正负值为尴尬的-12分', 'view_count': 7520, 'release_time': datetime.datetime(2018, 1, 27, 12, 5), 'author': 'youngcao', 'from': '腾讯体育','is_valibale': 1}, {'id': 4, 'type': '英超', 'title': '足总杯-曼联4-0英乙球队晋级 桑神首秀造两球', 'content': '2017-18赛季英格兰足总杯第4轮,曼联客场4比0击败英乙球队约维尔,顺利晋级下一轮。桑切斯迎来曼联首秀,并制造了两个入球', 'view_count': 6560, 'release_time': datetime.datetime(2018, 1, 27, 5, 49), 'author': 'ricazhang', 'from': '腾讯体育','is_valibale': 1}, {'id': 5, 'type': '英超', 'title': '这才配红魔7号!桑神首秀大腿级表演 回击嘘声质疑', 'content': '在今天凌晨对阵约维尔的首秀也值得期待。虽然在登场的72分钟时间里没有进球,但送出1次助攻且有有6次威胁传球的数据还是十分亮眼', 'view_count': 2760, 'release_time': datetime.datetime(2018, 1, 27, 6, 13), 'author': 'yaxinhao', 'from': '腾讯体育', 'is_valibale': 1}]

    这里很巧妙的利用了map函数,因为多条数据就可以进行迭代了,需要操作每条数据,这样就可以想到map函数

    接下来我们再用面向对象的方法来用python进行查询数据库

    1import pymysql

    2class MysqlSearch(object):

    3 def get_conn(self):

    4 '''连接mysql数据库'''

    5 try:

    6 self.conn = pymysql.connect(host='127.0.0.1',user='root',passwd='your password',port=3306,charset='utf8',db='news')

    7 except pymysql.Error as e:

    8 print(e)

    9 print('连接数据库失败')

    10

    11 def close_conn(self):

    12 '''关闭数据库'''

    13 try:

    14 if self.conn:

    15 self.conn.close()

    16 except pymysql.Error as e:

    17 print(e)

    18 print('关闭数据库失败')

    19

    20 def get_one(self):

    21 '''查询一条数据'''

    22 try:

    23 # 这个是连接数据库

    24 self.get_conn()

    25 # 查询语句

    26 sql = 'SELECT * FROM `new` WHERE `type`=%s'

    27 # 这个光标用来执行sql语句

    28 cursor = self.conn.cursor()

    29 cursor.execute(sql,('英超',))

    30 new = cursor.fetchone()

    31 # 返回一个字典,让用户可以按数据类型来获取数据

    32 new_dict = dict(zip([x[0] for x in cursor.description],new))

    33 # 关闭cursor

    34 cursor.close()

    35 self.close_conn()

    36 return new_dict

    37 except AttributeError as e:

    38 print(e)

    39 return None

    40 def get_all(self):

    41 '''获取所有结果'''

    42 sql = 'SELECT * FROM `new` '

    43 self.get_conn()

    44 try:

    45 cursor = self.conn.cursor()

    46 cursor.execute(sql)

    47 news = cursor.fetchall()

    48 # 将数据转为字典,让用户根据键来查数据

    49 news_list =list(map(lambda x:dict(zip([x[0] for x in cursor.description],[d for d in x])),news))

    50 # 这样也行,连续用两个列表生成式

    51 news_list = [dict(zip([x[0] for x in cursor.description],row)) for row in news]

    52 cursor.close()

    53 self.close_conn()

    54 return news_list

    55 except AttributeError as e:

    56 print(e)

    57 return None

    58

    59def main():

    60 # 获取一条数据

    61 news = MysqlSearch()

    62 new = news.get_one()

    63 if new:

    64 print(new)

    65 else:

    66 print('操作失败')

    67

    68 # 获取多条数据

    69 news = MysqlSearch()

    70 rest = news.get_all()

    71 if rest:

    72 print(rest)

    73 print(rest[7]['type'],rest[7]['title'])

    74 print('类型:{0},标题:{1}'.format(rest[12]['type'],rest[12]['title']))

    75 for row in rest:

    76 print(row)

    77 else:

    78 print('没有获取到数据')

    79

    80if __name__ == '__main__':

    81 main()

    这样就可以通过实例的方法来进行查询数据库了

    我们还可以根据页数来进行查询指定的数据数

    1 def get_more(self,page,page_size):

    2 '''查多少页的多少条数据'''

    3 offset = (page-1)*page_size

    4 sql = 'SELECT * FROM `new` LIMIT %s,%s'

    5 try:

    6 self.get_conn()

    7 cursor = self.conn.cursor()

    8 cursor.execute(sql,(offset,page_size,))

    9 news = [dict(zip([x[0] for x in cursor.description],new)) for new in cursor.fetchall()]

    10 cursor.close()

    11 self.close_conn()

    12 return news

    13 except AttributeError as e:

    14 print(e)

    15 return None

    16

    17def main():

    18 #获取某页的数据

    19 news = MysqlSearch()

    20 new = news.get_more(3,5)

    21 if new:

    22 for row in new:

    23 print(row)

    24 else:

    25 print('获取数据失败')

    26

    27if __name__ == '__main__':

    28 main()

    利用的是mysql的limit关键字,还有其他的,比如进行排序分组的感兴趣的可以自己尝试下

    增加数据到数据库

    1 def add_one(self):

    2 sql = 'INSERT INTO `new`(`title`,`content`,`type`,`view_count`,`release_time`) VALUE(%s,%s,%s,%s,%s)'

    3 try:

    4 self.get_conn()

    5 cursor = self.conn.cursor()

    6 cursor.execute(sql, ('title', 'content', 'type', '1111', '2018-02-01'))

    7 cursor.execute(sql, ('标题', '内容', '类型', '0000', '2018-02-01'))

    8 # 一定需要提交事务,要不不会显示,只会占位在数据库

    9 self.conn.commit()

    10 return 1

    11 except AttributeError as e:

    12 print('Error:', e)

    13 return 0

    14 except TypeError as e:

    15 print('Error:', e)

    16 # 发生错误还提交就是把执行正确的语句提交上去

    17 # self.conn.commit()

    18 # 下面这个方法是发生异常就全部不能提交,但语句执行成功的就会占位

    19 self.conn.rollback()

    20 return 0

    21 finally:

    22 cursor.close()

    23 self.close_conn()

    24

    25 def main():

    26 news = OperateSQL()

    27 if news.add_one():

    28 print('增加数据成功')

    29 else:

    30 print('发生异常,请检查!!!')

    31

    32 if __name__ == '__main__':

    33 main()

    因为是增加数据,所以需要提交事务,这就需要用到conn .commit()来进行提交,在增加数据后,如果不提交,数据库就不会显示。

    还有修改数据和删除数据就不贴出来了,只是把上面的sql变量的语句改成修改或者删除的语句就可以了,如果你还不会,建议练习下

    END

    作者:sergiojune Python爱好者社区专栏作者

    个人公众号:日常学python

    专注python爬虫,数据可视化,数据分析,python前端技术

    展开全文
  • 使用箭头键,可以将光标移到标记的文字,然后按下Alt+Shift+F10,此时就可以从操作菜单中选择所需的操作了。大家对于功能键最熟悉的莫过于F1(帮助)了,那么,若要查看word的其他功能键,只要按如下操作即可清楚...
  • 首先,杀死进程的主要命令为ps,grep,kill这三个指令。1、第一步是获取要监控进程的pid号:def get_process_pid(name):child = os.popen("ps -ef | grep "+name).readline()response = child.split(' ')print...
  • 使用python的idle写代码,不小心删掉代码,怎么撤销返回上一步? ctrl+z
  • 转载:python idle 常用快捷键(代码补全,debug)Mkdir700•2019 年 11 月 16 日Loading...蓝桥杯需要使用Python idle编辑器,平时用pycharm,为了比赛还是有必要熟悉下这个编辑器----------开始->程序->Python...
  • ai返回上一步的快捷键是“Ctrl+Z”。快捷键,又叫快速键或热键,指通过某些特定的按键、按键顺序或按键组合来完成一个操作。AI 快捷键大全:AI转曲线的快捷键 ctrl+shift+O移动工具【V】直接选取工具、组选取工具【A...
  • python程序中的进程操作之前我们已经了解了很多进程相关的理论知识,了解进程是什么应该不再困难了,刚刚我们已经了解了,运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此,运行起来的...
  • 本文主要介绍Python的高级特性:列表推导式、迭代器和生成器,是面试中经常会被问到的特性。因为生成器实现了迭代器协议,可由列表推导式来生成,所有,这三个概念作为一章来介绍,是最便于大家理解的,现在看不懂没...
  • Eclipse里编程代码,返回上一步的快捷键是636f70793231313335323631343130323136353331333365653261alt+←箭头。eclipse中几个最重要的快捷键。代码助手:Ctrl+Space(简体中文操作系统是Alt+/)。快速修正:Ctrl+1。...
  • # 关闭工作薄 self.close() # 返回cases(包含所有用例数据对象的列表) return cases def write_data(self, row, column, value): # 打开工作薄 self.open() # 写入数据 self.sheet.cell(row=row,column=column,value...
  • wtfPython是github的一个项目,作者收集了一些奇妙的Python代码片段,这些代码的输出结果会和我们想象中的不太一样;通过探寻产生这种结果的内部原因,可以让我们对Python里的一些细节有更广泛的认知。1.字典键的...
  • 而是让用户去使用,绝对要成一个安装包,如果刚刚入门的小伙伴,肯定没有想过这些,因为大部分人,还处于在搭建代码的状态下,但是还是希望大家先了解下,自己没事的时候拾起来玩耍也不错哦~以下内容基于Python的第...
  • 有些同学在阅读他人所写的代码(比如github)时,往往会对他人定义的...今天介绍一个Python的调试工具,叫做ipdb。有了这个工具我们就能轻易地进行各种调试了。安装ipdb最简单的方法就是pip install ipdb调用ipdb...
  • Eclipse里编程代码,返回上一步的快捷键是alt+←箭头。eclipse中几个最重要的快捷键。代码助手:Ctrl+Space(简e69da5e887aa3231313335323631343130323136353331333365643639体中文操作系统是Alt+/)。快速修正:Ctrl+1...
  • 展开全部return 会直接另函数返回,函数就2113运行结束了,所有5261该函数体内的代码都不再4102执行了,所以1653该函数体内的循环也不可能再继续运行。如果你需要让循环继续执行,就不能return函数,而应该选用break...
  • 一篇我们学习了Python模块知识,并自己写了一个test_module.py模块用于导入。这一篇我们来学习一个时间内置模块。一、time模块在Python中,通过有三种方式来表示时间时间戳(timestamp):通常来说,时间戳表示的...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 这段代码是我从知道里另一个问题复制下来的。请高手帮我改一下。@echooffsettaskname=calc.exeecho.%taskname%未运行,echo.等待%taskname%运行...echo.echo.goto:loop1:loop1for/f...这段代码是我从知道里另一个...
  • 一篇我们学习了Python模块知识,并自己写了一个test_module.py模块用于导入。这一篇我们来学习一个时间内置模块。 一、time模块 在Python中,通过有三种方式来表示时间 时间戳(timestamp):通常来说,时间戳...
  • 一篇我们学习了Python模块知识,并自己写了一个test_module.py模块用于导入。这一篇我们来学习一个时间内置模块。一、time模块在Python中,通过有三种方式来表示时间时间戳(timestamp):通常来说,时间戳表示的是...
  • 基本国内的天气都从这获取的 2:借用现成的接口 将数据获取到 保存到数据库 来为自己的网站提供服务 3:怎么 展示?怎么做接口?如何规范 可以利用django+rest_framework做接口(优雅的接口) 4开始行动 1新建...
  • 通过前三篇的教程,相信大家基本了解了微信开发的基本流程,先判断用户传入数据的类型MsgType,然后再获取用户输入的内容content,再对content进行处理,再返回给用户现在我们来加点料,在完成了前三篇的基础,...
  • 全文共2534字,预计学习时长8分钟来源:PexelsVS Code现在通过Python插件对Jupyter Notebooks提供本地支持。概述其主要功能的简单示例如下。尽管许多程序员选择使用IDE(即集成开发环境)并通过坚持使用而真正了解它,...
  • Python 中一切皆对象,函数也是对象。函数可以赋值给一个变量,函数可以当作参数传递个另一个函数,函数可以通过 return 语句返回函数。而装饰器就是一个能够接收函数并返回函数的函数。这话乍听起来有点绕,但装饰...
  • 返回函数就是将函数作为一个返回对象返回,因为对于python而言,一切皆对象,函数本身也是一个对象。这里只初步理解一下“返回函数”,后面在研究闭包的时候,再做深一步探究,为什么要需要返回函数。 (关于闭包,...
  • 今天上午将昨天遗留的问题解决了。项目是通过GitHub的api来调用当前托管的最受欢迎Python项目的...sort=stars首先使用requests来执行调用并返回json格式信息,然后将其转为字典来进行下一步处理:import requestsurl...
  • Python爬取APP的数据教程

    万次阅读 2019-08-10 21:59:54
    3.服务器向客户端(实际是抓包工具)返回服务器的CA证书 4.抓包工具拦截服务器的响应,获取服务器证书公钥,然后自己制作一张证书, 将服务器证书替换后发送给客户端。(这一步,抓包工具拿到了服务器证书的公钥)...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 162
精华内容 64
关键字:

python返回上一步

python 订阅