小编Saa*_*adH的帖子

import pandas as pd
import seaborn as sns

ser_test = pd.Series([1,0,1,4,6,0,6,5,1,3,2,5,1])
sns.kdeplot(ser_test, cumulative=True)

上面的代码生成以下 CDF 图：

但是当系列的元素被修改为：

ser_test = pd.Series([1,0,1,1,6,0,6,1,1,0,2,1,1])
sns.kdeplot(ser_test, cumulative=True)

我收到以下错误：

ValueError: 无法将字符串转换为浮点数：'scott'

运行时错误：选定的 KDE 带宽为 0。无法估计密度。

这个错误是什么意思，我如何解决它以生成 CDF（即使它非常倾斜）。

编辑：我使用的是 seaborn 版本 0.9.0

完整的跟踪如下：

ValueError: could not convert string to float: 'scott'

During handling of the above exception, another exception occurred:

RuntimeError                              Traceback (most recent call last)
<ipython-input-93-7cee594b4526> in <module>
      1 ser_test = pd.Series([1,0,1,1,6,0,6,1,1,0,2,1,1])
----> 2 sns.kdeplot(ser_test, cumulative=True)

~/.local/lib/python3.5/site-packages/seaborn/distributions.py in kdeplot(data, data2, shade, vertical, kernel, bw, gridsize, …

有没有更快的方法来创建和清零矩阵？
目前,我的代码涉及两个for循环:

var nodes = new Array(ast.length);

for (var i=0; i < nodes.length; i++){
    nodes[i] = new Array(ast.length);
    for (var j=0; j < nodes.length; j++)
        nodes[i][j]=0;
}

我有一个文档说明给定代码的平均时间复杂度为O(nlog ₂ n)

Random r = new Random();
int k = 1 + r.nextInt(n);
for (int i = 0; i < n ; i += k);

我计算了最好和最坏的情况:

最好的情况,k = n导致时间复杂性O(1).

最坏的情况,k = 1导致时间复杂性O(n).

平均情况如何是O(nlog ₂ n),这高于最坏情况.我错过了什么吗？

编辑:文档可能容易出错,所以在这种情况下,上述代码的平均时间复杂度是什么,为什么？

我有一个数据框，对于每个索引，我必须绘制两个条形图（两个系列）。以下代码给出的输出为：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df = pd.DataFrame(np.random.randint(0,20,size=(5, 2)), columns=list('AB'))
fig, ax = plt.subplots()
ax = df.sort_values('B', ascending=True).plot.barh(rot=0,ax=ax,hatch="/")
plt.show()

我想为每个条形分配单独的孵化。这样如果A有'/'阴影，B应该有'|'。我需要在代码中进行哪些修改？

我正在从文件中读取数据集(由空格分隔).我需要将所有列与数组中data的最后一列以及数组中的最后一列进行存储target.

你能指导我如何进一步前进吗？

这就是我到目前为止所拥有的:

with open(filename) as f:
    data = f.readlines()

或者我应该逐行阅读？

PS:列的数据类型也不同.

编辑:示例数据

faban       1   0   0.288   withspy
faban       2   0   0.243   withoutspy
simulated   1   0   0.159   withoutspy
faban       1   1   0.189   withoutspy

对于特定类型的ArrayList,我们可以在ArrayList中找到对象(特定类型的)的大小,并直接在O(1)中的任何索引处访问该对象.这是因为对象引用存储在ArrayList中的连续内存块中,因此通过跳过object_size * index内存位置,我们访问所需对象的引用所在的内存位置.
然而,在LinkedList中,我们必须遍历每个对象,直到我们到达所需的对象.

对于包含不同类型对象(具有不同大小)的通用ArrayList,是get(index i)在O(1)中完成的吗？如果是这样,怎么样？

我有一个递归函数,它返回树的叶节点(以嵌套对象的形式):

var retrieve = function (a)
{
    if (typeof retrieve.names == 'undefined') //would be true for the 1st pass only
        retrieve.names = []
    if (a.left != null)
        retrieve (a.left)
    if (a.right != null)
        retrieve (a.right)
    if (a.left == null && a.right == null)
        retrieve.names.push(a)
    return retrieve.names
}

这个函数的问题是,它对单个对象(树)完全正常,但是当在参数中传递另一个对象时,它只是将叶节点附加到已经从前一个树获得的叶节点.

例如,

// gets the leaf nodes of obj1 tree
obj1_leaves = retrieve(obj1) 

// instead of only getting leaf nodes of obj2, it appends them to leaf nodes of obj1
obj2_leaves = retrieve(obj2) …