小编blu*_*e13的帖子

我正在使用unittest库测试我的模块.这包括使用matplotlib库绘制一些图表.目前的问题是每次绘制图形时测试都会暂停,并且只有在我关闭图形后它才会恢复.我怎么能避免这个？

我从用户那里获得了一些参数并将函数传递给函数(每个函数在不同的类中),直到它最终到达一个执行某些处理的函数,然后解决方案从链中返回.在链上,函数变得越来越抽象,合并来自较低函数的多次运行的结果.

我应该在哪里使用*args和**kwargs？

我认为*args并且*kwargs可以用于函数不明确使用参数的每个函数.但是,需要定义实际参数,top_level以便用户知道函数期望的内容.

我应该在哪里定义输入的含义？

我认为应该定义它们,top_level因为这是最终用户可能希望查看文档的那个.

我应该在哪里定义默认值？

同样,我认为它们应该被定义,top_level因为这是最终用户与之交互的那个.

这是一个简单的例子,用于演示参数的传递,其中我没有展示函数如何变得越来越抽象或者它们如何与不同的类交互,因为我认为这是不必要的细节.

def top_level(a=1, b=1, c=1, d=1, e=1):
    """ Compute sum of five numbers.
    :param a: int, a
    :param b: int, b
    :param c: int, c
    :param d: int, d
    :param e: int, e
    :return: int, sum
    """
    return mid_level(a, b, c, d, e)


def mid_level(*args, **kwargs):
    return bottom_level(*args, **kwargs)


def bottom_level(a, b, c, d, e):
    return a + b …

当我在包含错误的存储库中运行玩笑测试时，堆栈跟踪指向错误的行号。这使得调试非常困难。例如：

预期错误

  \xe2\x97\x8f SimpleComponent \xe2\x80\xba renders\n\n    ReferenceError: retur is not defined\n\n      4 | export const Simple = () => {\n      5 |   const [count, setCount] = useState(0);\n    > 6 |   retur (\n        |   ^\n      7 |     <div>\n      8 |       <p>You clicked {count} times</p>\n      9 |       <button onClick={() => setCount(count + 1)}>Click me</button>\n\n      at Simple (src/SimpleComponent.jsx:6:3)\n      at Object.<anonymous> (tst/SimpleComponentTest.jsx:8:5)\n

收到错误

请注意，它指向错误的行号 - 34 而不是 6。

  \xe2\x97\x8f SimpleComponent \xe2\x80\xba renders\n\n    ReferenceError: retur is not defined\n\n\n\n      at Simple …

我想DataFrame通过读取文本文件来创建一个多索引.是否更快创建多索引,然后使用文本文件为其分配数据df.loc[[],[]],或者将行连接到DataFrame并设置最后的索引DataFrame？或者,使用列表或dict在从文件中读取数据时存储数据是否更快,然后DataFrame从中创建数据？是否有更多的pythonic或更快的选项？

示例文本文件:

A = 1
 B = 1
  C data
  0 1
  1 2
A = 1
 B = 2
  C data
  1 3
  2 4
A = 2
 B = 1
  C data
  0 5
  2 6

输出数据框架:

A B C data
1 1 0 1
    1 2
1 2 1 3
    2 4
2 1 0 5
    2 6

1月18日更新:这与如何使用Python解析复杂文本文件有关？我还写了一篇博客文章,解释了如何向初学者解析复杂文件.

我想合并 df_1 和 df_2 以创建 df_merged，但我想合并两者共有的列，而不是创建 A_x 和 A_y 之类的列。

index = [np.array(['foo', 'foo', 'qux', 'qux']),
         np.array(['one', 'two', 'one', 'two',])]
columns = ["A",  "B"]
df_1 = pd.DataFrame(np.random.randn(4, 2), index=index, columns=columns)

index = [np.array(['bar', 'bar', 'baz', 'baz',]),
         np.array(['one', 'two', 'one', 'two',])]
columns = ["A",  "B"]
df_2 = pd.DataFrame(np.random.randn(4, 2), index=index, columns=columns)

df_merge = pd.merge(df_1, df_2, left_index=True, right_index=True, how='outer')

print df_1
print df_2
print df_merge

df_1

                A         B
foo one  2.082229  1.575985
    two -0.805592  0.444195
qux one  0.368874  0.253556
    two  1.017632 -0.471978 …

我创建了一个函数,生成一个连续递增的字母表列表.A,B,C ......,Z.在Z之后,它转到AA,AB,AC ...... AZ.这种模式重复.这类似于MS Excel的列名.目前,此函数生成一个有限的字母表列表.

_column_name_generator() = ['A', 'B', ..., 'AA', 'AB', ..., 'BA', 'BB', ..., 'CV']

然后我可以结合一些有限列表迭代它,例如0-10.请参阅下面的代码.我想要的是创建一个生成器,它将为我提供一个无限长的递增字母表列表.

import string


def _column_name_generator():
    column_names = []
    for x in range(0, 100):
        if x < 26:
            column_names.append(string.ascii_uppercase[x % 26])
        else:
            column_names.append(column_names[x/26 - 1] + string.ascii_uppercase[x % 26])
    return column_names

container = []
for column_name, num in zip(_column_name_generator(), range(0, 10)):
    container.append(column_name + str(num))

print _column_name_generator()
print container

container = ['A0', 'B1', 'C2', 'D3', 'E4', 'F5', 'G6', 'H7', 'I8', 'J9']

我对JS中异步任务如何调度的理解

如果我有任何错误，请纠正我：

JS 运行时引擎代理由一个事件循环驱动，它收集任何用户和其他事件，将任务排入队列以处理每个回调。

事件循环持续运行，并具有以下思考过程：

• 是执行上下文堆栈（通常被称为调用堆栈）是空的？
• 如果是，则将微任务队列（或作业队列）中的任何微任务插入调用堆栈。继续这样做，直到微任务队列为空。
• 如果微任务队列为空，则将任务队列（或回调队列）中最早的任务插入调用栈

因此，任务和微任务的处理方式有两个主要区别：

• 微任务（例如承诺使用微任务队列来运行它们的回调）优先于任务（例如来自其他 Web API 的回调，例如setTimeout）
• 此外，所有微任务都在任何其他事件处理或呈现或任何其他任务发生之前完成。因此，微任务之间的应用环境基本相同。

Promise 是在ES6 2015中引入的。我假设微任务队列也在 ES6 中引入。

我的问题

引入微任务队列的动机是什么？为什么不继续使用任务队列进行 Promise 呢？

更新 #1 - 我正在寻找规范更改的明确历史原因 - 即它旨在解决的问题是什么，而不是关于微任务队列好处的固执己见的答案。

参考：

• 深入：微任务和 JavaScript 运行时环境
• HTML 规范事件循环处理模型
• Javascript-hard-parts-v2
• loupe - 了解 JavaScript 的调用堆栈/事件循环/回调队列交互的可视化工具
• 在 JavaScript 中通过 queueMicrotask() 使用微任务

背景

• 我有一个连接到 RDS 数据库的 lambda。RDS 数据库和 lambda 位于 VPC 中。开发人员只能通过 Bastion 实例访问该数据库。
• 在开发过程中，我们可以使用sam测试 lambda 。这对于不依赖于数据库的 API 来说效果很好。
• 对于依赖于数据库的 API，我理想情况下希望连接到在 Gamma 阶段运行的数据库实例。但是，我们无法直接连接到它，因为它位于 VPC 中。

我尝试过的

• 为了解决这个问题，我们可以在堡垒实例上使用带有端口转发的 SSM 代理，以便可以在 Mac 的本地主机上访问数据库。参见说明。示例代码如下：

aws ssm start-session --target <instance-id> --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters host="mydb.example.us-east-2.rds.amazonaws.com",portNumber="3306",localPortNumber="3306"

• 我现在可以通过 CLI 或像Psequelhttp://127.0.0.1:3306/这样的 GUI在本地连接到它。无需使用 SSH。
• 但是，如果我尝试让 lambda 连接到http://127.0.0.1:3306/，则会收到错误Connection refused。
• 我的理解是，这是因为127.0.0.1解析为 docker 容器的本地主机而不是我机器的本地主机。
• 根据码头工人文档，host.docker.internal ... resolves to the internal IP address used by the host
• 但是，如果我尝试让 lambda 连接到http://host.docker.internal:3306/ …

假设我有一个简单的基于图像的组件：

// ./Figure.js\n\nconst Figure = ({src}) => (\n    <img\n        src={src}\n        width="100%"\n    />\n);\n

我想测试它的宽度是100%。

我的测试：

// ./Figure.test.js\n\nimport Figure from './Figure'\nimport { render, screen } from '@testing-library/react'\n\ndescribe('Figure', () => {\n    const setup = () => {\n        return render(\n            <Figure\n                src="https://src.com"\n            />\n        )\n    }\n\n    it('has the right width', () => {\n        setup()\n\n        const image = screen.getByAltText('alt')\n\n        expect(image.src).toBe('https://src.com/')\n        expect(image.width).toBe("100%")\n    })\n})\n

但是，这给了我一个错误：

  \xe2\x97\x8f Figure \xe2\x80\xba renders\n\n    expect(received).toBe(expected) // Object.is equality\n\n    Expected: "100%"\n    Received: 0\n

问题：如何在不使用快照的情况下使用 React …

如何使用 pipenv 以默认使用站点包而不是使用 PyPi 索引的方式安装包。就上下文而言，我的站点包文件夹中有一个公司批准的包列表。

我仍然想使用 venv 以便正确捕获这些依赖项，而不是直接使用站点包。

图例的可打印文档提供有关隐藏图例条目的信息：

import plotly.plotly as py
import plotly.graph_objs as go

trace0 = go.Scatter(
    x=[1, 2, 3, 4, 5],
    y=[1, 2, 3, 4, 5],
    showlegend=False
)

trace1 = go.Scatter(
    x=[1, 2, 3, 4, 5],
    y=[5, 4, 3, 2, 1],
)

data = [trace0, trace1]
fig = go.Figure(data=data)

py.iplot(fig, filename='hide-legend-entry')

但是，我正在从中生成图DataFrame。因此，我已经有了一个可圈可点的图形，因此没有设置showlegend=False每个跟踪的自由。

import pandas as pd
import plotly.offline as py
import cufflinks as cf
cf.go_offline()

df = pd.DataFrame(data=[[0, 1, 2], [3, 4, 5]], columns=['A', 'B', 'C'])
py.plot(df.iplot(kind='scatter', asFigure=True))

我想隐藏列列表。 …

我已经定义了一个NewDataStructure继承自另一个类的子类.作用于对象本身的方法可以正常使用此子类.但是,创建副本的方法,返回父类的对象,而不是子类.当我在其他方法中调用该方法时,这会导致很多问题.

有没有办法专门指示父类的命名方法应该返回子类的对象？

有没有办法指示所有继承的方法应该返回子类的对象,而不是父类？

也许我可以将返回的对象传递给__init__我的类的函数？我需要相应地修改我__init__...... Pythonic的方法是什么？

import pandas as pd


class NewDataStructure(pd.DataFrame):
    def __init__(self, data, index, title):
        super(NewDataStructure, self).__init__(data=data, index=index)
        self.title = title


new_data_variable = NewDataStructure(data=None, index=None, title="")

changed = new_data_variable.unstack()

new_data_variable.reset_index(inplace=True)
unchanged = new_data_variable

print type(changed)
print type(unchanged)

<class 'pandas.core.series.Series'> 
<class '__main__.NewDataStructure'>

index = [np.array(['foo', 'foo', 'qux']),
         np.array(['a', 'b', 'a'])]
data = np.random.randn(3, 2)
columns = ["X", "Y"]
df = pd.DataFrame(data, index=index, columns=columns)
df.index.names = ["Level0", "Level1"]
print df

                      X         Y
Level0 Level1                    
foo    a       0.418549  0.252685
       b      -1.307099  0.202833
qux    a       0.046095 -0.968976

新水平

我想获取df的索引并创建一个新的MultiIndex，该索引现在具有附加级别。

new_level_name = "New level"
new_level_labels = ['p', 'q']
# new_multi-index 

所需的多索引

Level0 Level1 Level2                    
foo    a      p       
              q       
       b      p      
              q       
qux    a      p      
              q