小编Ric*_*cco的帖子

一个 n 维数组有 2n 个边（一个一维数组有 2 个端点；一个二维数组有 4 个边或边；一个 3 维数组有 6 个二维面；一个 4 维数组有 8 个边；等等。）。这类似于抽象的 n 维立方体所发生的情况。

我想检查一个 n 维数组的所有边是否只由零组成。以下是边由零组成的数组的三个示例：

# 1D
np.array([0,1,2,3,0])
# 2D
np.array([[0, 0, 0, 0],
          [0, 1, 0, 0],
          [0, 2, 3, 0],
          [0, 0, 1, 0],
          [0, 0, 0, 0]])
# 3D
np.array([[[0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0]],
          [[0, 0, 0, 0],
           [0, 1, 2, 0],
           [0, 0, 0, 0]],
          [[0, 0, 0, 0],
           [0, 0, 0, …

class A(object):
    pass

class B(A):
    pass

o = object()
a = A()
b = B()

虽然我可以改变a.__class__，但我不能做同样的事情o.__class__（它会引发TypeError错误）。为什么？

例如：

isinstance(a, A) # True
isinstance(a, B) # False
a.__class__ = B
isinstance(a, A) # True
isinstance(a, B) # True

isinstance(o, object) # True
isinstance(o, A) # False
o.__class__ = A # This fails and throws a TypeError
# isinstance(o, object)
# isinstance(o, A)

我知道这通常不是一个好主意，因为如果处理不当会导致一些非常奇怪的行为。这只是为了好奇。

Python 没有内置的任意精度浮点数。这是一个例子：

>>> float(4.4257052820783003)
4.4257052820783

因此，无论您使用什么，都不能拥有任意精度的浮点对象。

假设我有一个包含任意精度浮点数的JSON 字符串( )。json_string = '{"abc": 4.4257052820783003}'如果我加载该字符串，Python 将剪切该数字：

>>> dct = json.loads(json_string)
>>> dct
{'abc': 4.4257052820783}

我设法通过使用以下方法来避免这种信息丢失decimal.Decimal：

>>> dct = json.loads(json_string, parse_float=Decimal)
>>> dct
{'abc': Decimal('4.4257052820783003')}

现在，我想将此dct对象序列化为原始 JSON 格式的字符串。json.dumps(dct)显然不起作用（因为 Decimal 类型的对象不可 JSON 序列化）。我尝试子类化json.JSONEncoder并重新定义其default方法：

class MyJSONEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, Decimal):
            return str(o)
        return super().default(o)

但这显然是创建一个字符串而不是数字：

>>> MyJSONEncoder().encode(dct)
'{"abc": "4.4257052820783003"}'

如何将Decimal对象序列化为 JSON 数字（实数）而不是 JSON 字符串？换句话说，我希望编码操作返回原始json_string字符串。理想情况下不使用外部包（但仍然欢迎使用外部包的解决方案）。

这个问题当然非常相关，但我在那里找不到答案：Python …

假设我有两个字典，并且我知道想要测量检查字典中是否有某个键所需的时间。我尝试运行这段代码：

from timeit import timeit

dct1 = {str(i): 1 for i in range(10**7)}
dct2 = {i: 1 for i in range(10**7)}

print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))

以下是我得到的结果：

2.529034548999334
2.212983401999736

现在，假设我尝试在两个字典中混合整数和字符串，并再次测量访问时间：

dct1[7] = 1
dct2["7"] = 1

print(timeit('"7" in dct1', setup='from __main__ import dct1', number=10**8))
print(timeit('7 in dct1', setup='from __main__ import dct1', number=10**8))
print(timeit('7 in dct2', setup='from __main__ import dct2', number=10**8))
print(timeit('"7" in dct2', setup='from __main__ import dct2', number=10**8))

我得到一些奇怪的东西： …

str.strip您可以在文档中找到以下内容：

chars参数是一个字符串，指定要删除的字符集。如果省略 或None，则chars参数默认删除空格。

现在我的问题是：哪些特定字符被视为空格？

这些函数调用共享相同的结果：

>>> ' '.strip()
''
>>> '\n'.strip()
''
>>> '\r'.strip()
''
>>> '\v'.strip()
''
>>> '\x1e'.strip()
''

在这个相关问题中，用户提到该str.strip函数适用于ASCII 空白字符的超集（换句话说， 的超集string.whitespace）。更具体地说，它适用于所有 unicode 空白字符。

此外，我相信（但我只是猜测，我没有证据）c.isspace()返回True的每个字符c也将被删除str.strip。那是对的吗？如果是这样，我想可以只c.isspace()对每个 unicode 字符c运行，并给出默认情况下删除的空白字符列表str.strip。

>>> ' '.isspace()
True
>>> '\n'.isspace()
True
>>> '\r'.isspace()
True
>>> '\v'.isspace()
True
>>> '\x1e'.isspace()
True

我的假设正确吗？如果是这样，我怎样才能找到一些证据？有没有更简单的方法来知道哪些特定字符被自动删除str.strip？

我想在输出原始隐藏状态的裸 BERT 模型转换器之上添加一个密集层，然后微调生成的模型。具体来说，我正在使用这个基本模型。这是模型应该做的：

1. 对句子进行编码（句子的每个标记有 768 个元素的向量）
2. 只保留第一个向量（与第一个标记相关）
3. 在此向量之上添加一个密集层，以获得所需的转换

到目前为止，我已经成功地对句子进行了编码：

from sklearn.neural_network import MLPRegressor

import torch

from transformers import AutoModel, AutoTokenizer

# List of strings
sentences = [...]
# List of numbers
labels = [...]

tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-xxl-cased")
model = AutoModel.from_pretrained("dbmdz/bert-base-italian-xxl-cased")

# 2D array, one line per sentence containing the embedding of the first token
encoded_sentences = torch.stack([model(**tokenizer(s, return_tensors='pt'))[0][0][0]
                                 for s in sentences]).detach().numpy()

regr = MLPRegressor()
regr.fit(encoded_sentences, labels)

通过这种方式，我可以通过用编码的句子来训练神经网络。然而，这种方法显然没有微调基础 BERT 模型。有谁能够帮助我？如何构建可以完全微调的模型（可能在 pytorch 中或使用 Huggingface 库）？

我有一个项目列表，这些项目应该一个接一个地插入到类似列表的数据结构中，并且我有每个项目应该插入的索引。例如：

items = ['itemX', 'itemY', 'itemZ']
indexes = [0, 0, 1]

预期的结果是有这样的名单：result = ['itemY', 'itemZ', 'itemX']。

我可以用这种简单的方法得到这个结果：

result = []
for index, item in zip(indexes, items):
    result.insert(index, item)

然而，一旦列表变得巨大（复杂度为 O(n^2)），这是一种非常缓慢的方法。有没有（相对简单的）方法来改进我的基本方法？我想我在插入元素时必须查看其他数据结构，最后将该数据结构转换为我的result列表。树木是个好选择吗？插入可以在 O(log(n))（而不是 O(n)）中完成，但是我应该使用哪种特定的树状结构？

或者也许可以通过一起查看所有索引（而不是一个一个地使用它们）来实现一些好的目标。

对于我的缓慢方法来说，这可能是最糟糕的情况（总是在列表的开头插入项目）：

n = 10**6 # some large number
items = list(range(n))
indexes = [0] * n

我有一个 json 文件，如下所示：

[{"A": 0, "B": "x"}, {"A": 1, "B": "y", "C": 0}, {"A": 2, "B": "z", "C": 1}]

由于“C”列包含 NaN 值（第一行），pandas 自动推断其 dtype 为“float64”：

>>> pd.read_json(path).C.dtype
dtype('float64')

但是，我希望“C”列的数据类型为“Int32”。pd.read_json(path, dtype={"C": "Int32"})不起作用：

>>> pd.read_json(path, dtype={"C": "Int32"}).C.dtype
dtype('float64')

相反，pd.read_json(path).astype({"C": "Int32"})确实有效：

>>> pd.read_json(path).astype({"C": "Int32"}).C.dtype
Int32Dtype()

为什么会出现这种情况？如何仅使用该pd.read_json函数设置正确的数据类型？

我正在使用 Python 包中的一个类，我向该类传递必须只有一个参数的函数，例如：

def exampleFunction1(only_argument_1):
    
    doSomething1(only_argument_1) #perform some operations

然后，一旦以上述方式定义了所有需要的函数，我需要以这种方式传递它们：

python_package_class.function1 = exampleFunction1
python_package_class.function2 = exampleFunction2
python_package_class.function3 = exampleFunction3

现在让我们假设 doSomething 对于我的所有函数都是相同的，除了它需要另一个可以更改的参数这一事实，例如（1、2 和 3 只是示例，参数可以是任何内容）：

def exampleFunction1(only_argument_1):
    
    doSomething(1, only_argument_1) #perform some operations

def exampleFunction2(only_argument_2):
    
    doSomething(2, only_argument_2) #perform some operations

def exampleFunction3(only_argument_3):
    
    doSomething(3, only_argument_3) #perform some operations

通过仅定义一个 exampleFunction并向其传递两个参数，可以大大简化这一过程：

def exampleFunction(a, only_argument_1):
    
    doSomething(a, only_argument_1) #perform some operations

但是，不幸的是，这会给我带来一个错误，因为正如我所说，我正在使用的 Python 包严格要求函数只接受一个参数。

所以我的问题是，是否有一种“隐式方式”将参数传递 a 给以下代码行中的 exampleFunction ？

python_package_class.function1 = exampleFunction

一方面我们有

• 列表理解 [x for x in range(10)]
• 集合理解 {x for x in range(10)}
• 字典理解 {x: x for x in range(10)}

另一方面我们有

• 生成器表达式 (x for x in range(10))

为什么前三个表达式称为“理解”，而最后一个称为“表达式”？它们几乎以相同的方式表示，我猜它们也以非常相似的方式工作。这背后有什么微妙的原因吗？这只是为了好奇。

参考：

• PEP 289 -- 生成器表达式
• PEP 202 -- 列表理解