小编jsb*_*eno的帖子

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

我正在尝试根据Soundcloud登录来授权我的网站上的用户.

它使用Oauth身份验证.

用户必须单击我站点上的按钮,然后重定向到Soundcloud站点,并在其中登录.

之后,用户被重定向回我的网站,我必须获得accessToken.

这失败并显示消息:请求的URL以HTTP代码0响应.

如果你需要,我已经抛弃了卷曲的东西:

 [data]; False
 [info][url]                    : https://api.soundcloud.com/oauth2/token
       [content_type]           ; NULL
       [http_code]              : 0
       [header_size]            : 0
       [request_size]           : 0
       [filetime]               : -1
       [ssl_verify_result]      : 0
       [redirect_count]         : 0
       [total_time]             : 0.031
       [namelookup_time]        : 0
       [connect_time]           : 0.031
       [pretransfer_time]       : 0
       [size_upload]            : 0
       [size_download]          : 0
       [speed_download]         : 0
       [speed_upload]           : 0
       [download_content_length]: -1
       [upload_content_length]  : -1
       [starttransfer_time]     : 0
       [redirect_time]          : 0
       [certinfo]               []

我执行的代码:

    $soundcloud = new SoundcloudModel('*****', '*****', '*****');

    try {
        $accessToken …

例如,如果我用Java创建JVM,是否有可能使我实现的实现比我用于构建此实现的原始实现更快,即使我的实现是基于原始实现构建的,甚至可能依赖于在那个实现？

(令人困惑......)

看看PyPy.它是用Python制作的Python的JIT编译器.这没关系,但是它如何声称比它正在使用并依赖于Python的原始实现更快？

我有一个关于与numpy和字符串数组进行相等比较的问题.假设我定义了以下数组:

x = np.array(['yes', 'no', 'maybe'])

然后我可以测试与其他字符串的相等性,并且它与单个字符串进行元素明智的比较(以下,我认为,这里的广播规则:http://docs.scipy.org/doc/numpy-1.10.1/user/ basics.broadcasting.html？):

'yes' == x
#op : array([ True, False, False], dtype=bool)

x == 'yes'
#op : array([ True, False, False], dtype=bool)

但是,如果我与unicode字符串进行比较,我会得到不同的行为,只有当我将数组与字符串进行比较时才会发生元素明智的比较,如果我将字符串与数组进行比较,则只进行一次比较.

x == u'yes'
#op : array([ True, False, False], dtype=bool)

u'yes' == x
#op : False

我在numpy docs中找不到这种行为的细节,并希望有人可以解释或指出为什么与unicode字符串的比较行为不同的细节？

我需要运行用户提交的应用程序。我的代码看起来像：

def run_app(app_path):
    inp = open("app.in", "r")
    otp = open("app.out", "w")

    return subprocess.call(app_path, stdout=otp, stdin=inp)

现在，由于我无法控制用户将提交的内容，因此我想限制应用程序输出的大小。其他诸如尝试访问未经授权的系统资源和滥用 CPU 周期之类的事情都受到 apparmor 规则实施的限制。允许运行的最长时间由父进程处理（在 python 中）。现在，流氓应用程序仍然可以通过将大量数据写入其标准输出来尝试淹没服务器系统，因为知道标准输出正在保存到文件中。

我不想将 AppArmors RLIMIT 或内核模式下的任何内容用于 stdout/stderr 文件。能够使用标准库从 python 中做到这一点会很棒。

我目前正在考虑创建文件的子类，并在每次写入时检查已将多少数据写入流。或者创建一个设置了最大长度的内存映射文件。

但我觉得可能有一种更简单的方法来限制我还没有看到的文件大小。

编辑：正如指出的蒂埃里Lathuille，PEP567，在那里ContextVar被引入，却没有设计地址发生器（不像撤回PEP550）。尽管如此，主要问题仍然存在。如何编写可在多个线程，生成器和asyncio任务中正常运行的有状态上下文管理器？

我有一个带有一些可以在不同“模式”下运行的功能的库，因此可以通过本地上下文来更改其行为。我正在查看contextvars可靠地实现此功能的模块，因此可以在不同的线程，异步上下文等环境中使用它。但是，我很难获得一个正确的简单示例。考虑以下最小设置：

from contextlib import contextmanager
from contextvars import ContextVar

MODE = ContextVar('mode', default=0)

@contextmanager
def use_mode(mode):
    t = MODE.set(mode)
    try:
        yield
    finally:
        MODE.reset(t)

def print_mode():
   print(f'Mode {MODE.get()}')

这是一个带有生成器功能的小测试：

def first():
    print('Start first')
    print_mode()
    with use_mode(1):
        print('In first: with use_mode(1)')
        print('In first: start second')
        it = second()
        next(it)
        print('In first: back from second')
        print_mode()
        print('In first: continue second')
        next(it, None)
        print('In first: finish')

def second():
    print('Start second')
    print_mode() …

使用Multiprocessing包中的Process和Pool模块,并不断访问该_bootstrap方法的引用.

从我所看到的方法导入一个multiprocessing util.py模块,并使用它的方法(还有其他一些组合)来trace,log和manage子进程.

def _bootstrap(self):
    from . import util
    global _current_process

    try:
        self._children = set()
        self._counter = itertools.count(1)
        try:
            sys.stdin.close()
            sys.stdin = open(os.devnull)
        except (OSError, ValueError):
            pass
        _current_process = self
        util._finalizer_registry.clear()
        util._run_after_forkers()
        util.info('child process calling self.run()')
        try:
            self.run()
            exitcode = 0
        finally:
            util._exit_function()
    except SystemExit, e:
        if not e.args:
            exitcode = 1
        elif isinstance(e.args[0], int):
            exitcode = e.args[0]
        else:
            sys.stderr.write(str(e.args[0]) + '\n')
            sys.stderr.flush()
            exitcode = 1
    except:
        exitcode = 1 …

如果我运行以下代码:

a={}
a[input("key: ")] = input("value: ")

口译员首先提示我a value input然后是key input.

这背后的原因是什么？

我有三个课程如下:

class Page(object):
    def __init__(self, Obj_a, Obj_b):
        super().__init__(Obj_a, Obj_b)

class Report(object):
    def __init__(self, Obj_a, Obj_b):
        super().__init__()

class ReportingPage(Page,Report):
    def __init__(self, Obj_a, Obj_b):
        super().__init__(Obj_a, Obj_b)

我实例化一个ReportingPage对象.要做到这一点,Python爬行MRO:

1. Page首先调用该对象,因为它首先在继承列表中排序ReportingPage,然后调用它自己的__init__方法.

2. 然后它也是这样做的Report.

我不明白的两件事:

1. 为什么我必须将参数传递给super.__init__in Page,什么Page时候才会调用__init__它继承的内容,object.

2. 为什么我不必为此做同样的事情Report.

我有两个类应该为两个独立的库实现相同的测试用例（我们称它们为LibA和LibB）。到目前为止，我定义了要在抽象基类中实现的测试方法，以确保两个测试类都实现所有所需的测试：

from abc import ABC, abstractmethod

class MyTests(ABC):
    @abstractmethod
    def test_foo(self):
        pass

class TestsA(MyTests):
    def test_foo(self):
        pass

class TestsB(MyTests):
    def test_foo(self):
        pass

这按预期工作，但仍然可能发生的是，在LibB 上工作的人不小心添加了一个test_bar()方法TestB而不是基类。在这种情况下test_bar()，TestA课堂上的失踪将被忽视。

有没有办法禁止向（抽象）基类添加新方法？目标是强制在基类中添加新方法，从而强制在所有派生类中实现新方法。