小编jsb*_*eno的帖子

下面是python中使用PIL突出显示两个图像之间差异的当前工作代码.但其余的图像都是黑色的.

目前我想要显示背景以及突出显示的图像.

无论如何,我可以保持节目的背景更轻,只是突出差异.

from PIL import Image, ImageChops
point_table = ([0] + ([255] * 255))

def black_or_b(a, b):
    diff = ImageChops.difference(a, b)
    diff = diff.convert('L')
    # diff = diff.point(point_table)
    h,w=diff.size
    new = diff.convert('RGB')
    new.paste(b, mask=diff)
    return new

a = Image.open('i1.png')
b = Image.open('i2.png')
c = black_or_b(a, b)
c.save('diff.png')

!https://drive.google.com/file/d/0BylgVQ7RN4ZhTUtUU1hmc1FUVlE/view?usp=sharing

如果我需要python中的for循环

for i in range(1,42):
    print "spam"

但不要使用"i"表示任何pylint抱怨未使用的变量.我该怎么处理？我知道你可以这样做:

for dummy_index in range(1,42):
    print "spam"

但这样做对我来说似乎很奇怪,有更好的方法吗？

我是python的新手,请原谅我,如果我错过了一些明显的东西.

我在 python 程序中导入了一些包。但其中很多只在程序开始时被调用。这些包是否保存在内存中直到整个程序运行完毕？调用释放内存后我可以删除它们吗？

我正在尝试修补__new__一个类的方法，但它没有按我的预期工作。

from contextlib import contextmanager

class A:
    def __init__(self, arg):
        print('A init', arg)

@contextmanager
def patch_a():
    new = A.__new__

    def fake_new(cls, *args, **kwargs):
        print('call fake_new')
        return new(cls, *args, **kwargs) 
        # here I get error: TypeError: object.__new__() takes exactly one argument (the type to instantiate)

    A.__new__ = fake_new
    try:
        yield
    finally:
        A.__new__ = new

if __name__ == '__main__':
    A('foo')
    with patch_a():
        A('bar')
    A('baz')

我期望以下输出：

A init foo
call fake_new
A init bar
A init baz

但是在call fake_new我收到错误之后（请参阅代码中的注释）。对我来说，我似乎只是装饰一个 …

我不知道任何Ruby,现在正在阅读一些文档.在阅读有关使用代码块和"yield"关键字之后我怀疑是否可以将多个代码块传递给函数,并且在被调用函数中随意使用这两个代码块.

我是V8的新手,并计划在python Web应用程序中使用它.目的是让用户提交和执行某些JS脚本.显然这是一个安全威胁,所以我正在寻找资源来记录人们可能"锁定"v8的方式.例如,我可以创建一个允许调用的白名单吗？或者不允许引用黑名单库？

Python 3带来了yield from语义.据我所知,它应该屈服于最外层的生成器,在这种情况下,我希望这个代码是线性的N.

from collections import Iterable

def flatten(L):
  for e in L:
    if isinstance(e, Iterable):
      yield from flatten(e)
    else:
      yield e 

N = 100
L = [-1]
for i in range(N):
  L = [i, [L], i]
for i in range(100):
  f = list(flatten(L))
print(len(f))

N=200然而,如果我设置的计算时间大约是计算时间的四倍,则表明展平是长度的二次方L.我无法理解为什么会这样,因为代码只访问每个元素一次,yield from关键字应该直接从内部生成器发送值到收集到列表中的术语.

这是一个错误,根本不是故意的,还是我使用它错了？有没有一种很好的方法在Python中进行O(N)展平？

我在包装类方面遇到问题，并且无法弄清楚我做错了什么。我如何让该包装器与带有“self”参数的任何类函数一起使用？

这是针对 Python 3.7.3 的。问题是我记得包装器以前工作过，但似乎有些东西发生了变化……也许我现在只是做了一些错误的事情，而以前没有。

class SomeWrapper:

    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # this fails because self is not passed
        # ERROR: __init__() missing 1 required positional argument: 'self'
        func_ret = self.func(*args, **kwargs)

        # this is also wrong, because that's the wrong "self"
        # ERROR: 'SomeWrapper' object has no attribute 'some_func'
        # func_ret = self.func(self, *args, **kwargs)

        return func_ret


class SomeClass:

    SOME_VAL = False

    def __init__(self):
        self.some_func()
        print("Success")

    @SomeWrapper
    def some_func(self):
        self.SOME_VAL = True

    def …

这是我的小fastapi应用程序：

from datetime import datetime
import asyncio

import uvicorn
from fastapi import FastAPI


app = FastAPI()

@app.get("/delayed")
async def get_delayed():
    started = datetime.now()
    print(f"Starting at: {started}")
    await asyncio.sleep(10)
    ended = datetime.now()
    print(f"Ending at: {ended}")
    return {"started": f"{started}", "ended": f"{ended}"}

if __name__ == "__main__":
    uvicorn.run("fastapitest.main:app", host="0.0.0.0", port=8000, reload=True, workers=2)

当我连续两次调用它时，第二个函数中的代码直到第一个请求完成后才开始执行，产生如下输出：

Starting at: 2021-09-17 14:52:40.317915
Ending at: 2021-09-17 14:52:50.321557
INFO:     127.0.0.1:58539 - "GET /delayed HTTP/1.1" 200 OK
Starting at: 2021-09-17 14:52:50.328359
Ending at: 2021-09-17 14:53:00.333032
INFO:     127.0.0.1:58539 - "GET /delayed …

我偶然发现了这段代码，我觉得很奇怪，因为它似乎违反了 python 内置函数直接从对象的类调用 dunder 方法的事实。举__call__个例子，如果我们定义类A如下：

class A:\n    @property\n    def __call__(self):\n        def inner():\n            return 'Called.'\n        return inner\n\na = A()\na() # return 'Called.'\n\ntype(a).__call__(a) # return 'property' object is not callable. \n

然而，这种行为似乎与Python官方文档中所说的相矛盾：

\n

object.__call__(self[, args...])当实例\xe2\x80\x9c称为\xe2\x80\x9d\nas函数时调用；如果定义了此方法，则x(arg1, arg2, ...)大致\n转换为type(x).__call__(x, arg1, ...).

\n

谁能解释一下这是怎么回事？