小编Aka*_*all的帖子

我理解JavaScript中的闭包是如何工作的,但我的问题是为什么你会遇到制作闭包以保存变量的所有麻烦？难道你不能让变量全局化吗？或者这会使全局范围变得混乱并使您的代码容易出错.

可能重复:
阴影的概念

我很困惑在向上转换期间如何在Java中处理类的字段.例如:

class SuperClass
{
    String myString = "String in SuperClass";

    public void myMethod()
    {
        System.out.println("Method in SuperClass");
    }
}

class SubClass extends SuperClass
{
    String myString = "String in SubClass";

    public void myMethod()
    {
        System.out.println("Method in SubClass");
    }
}

class Question
{
    public static void main(String[] args)
    {
        SuperClass test = new SubClass();
            // object test is an instance of SubClass
            // but I am telling the compiler to treat it as SuperClass

        test.myMethod();
        System.out.println(test.myString);

    }
}

输出: …

我正在为即将到来的求职面试练习算法,我无法正确实现这一点.我也试图最大限度地提高效率.这是问题所在:

最大限度地提高销售金属棒的业务利润.如果您销售长度为L的N根金属棒,则会收到N*L*metal_price.其余较小的金属杆将被抛弃.要切割金属棒,您需要为每次切割支付cost_per_cut.您可以获得的最大利润是多少？

constraints:
lengths will be 1 to 50 elements, inclusive.
each element of length will lie in range [1,10000]
1 <= metal_price, cost_per_cut <=1000

样本输入:

cost_per_cut =1

metal_price =10

lengths = [26,103, 59]

return: 1770

本书如何解决这个问题,最佳长度为6.我们从第一根杆上切下4根长度为6的长度,并从中拉出2根长度.接下来我们从第2个杆上切下17个长度为6的长度,然后扔掉长度为1的一块,第三个,我们剪下9个长度为6的长度,然后扔掉一块长度为5.所以总共做了30次切割.因此,30*6*10 - 30*1 - 1770

这是我到目前为止的尝试:

def  maxProfit( cost_per_cut,  metal_price,  lengths):

     profit =0
     for num in lengths:

我只是不确定如何去做这件事.我应该迭代这些数字,看看它们可被整除的最低数字并使用它吗？有任何想法吗？

如果正确理解,当计算随机森林估计量时,通常会应用自举,这意味着仅使用来自样本(i)的数据构建树(i),并选择替换.我想知道sklearn RandomForestRegressor使用的样本的大小是多少.

我看到的唯一一件事就是:

bootstrap : boolean, optional (default=True)
    Whether bootstrap samples are used when building trees.

但是没有办法指定样本大小的大小或比例,也没有告诉我默认的样本大小.

我觉得应该有办法至少知道默认的样本大小是什么,我错过了什么？

我试图statsmodels在Python中运行Augmented Dickey-Fuller测试,但我似乎错过了一些东西.

这是我正在尝试的代码:

import numpy as np
import statsmodels.tsa.stattools as ts

x = np.array([1,2,3,4,3,4,2,3])
result = ts.adfuller(x)

我收到以下错误:

Traceback (most recent call last):
  File "C:\Users\Akavall\Desktop\Python\Stats_models\stats_models_test.py", line 12, in <module>
    result = ts.adfuller(x)
  File "C:\Python27\lib\site-packages\statsmodels-0.4.1-py2.7-win32.egg\statsmodels\tsa\stattools.py", line 201, in adfuller
    xdall = lagmat(xdiff[:,None], maxlag, trim='both', original='in')
  File "C:\Python27\lib\site-packages\statsmodels-0.4.1-py2.7-win32.egg\statsmodels\tsa\tsatools.py", line 305, in lagmat
    raise ValueError("maxlag should be < nobs")
ValueError: maxlag should be < nobs

我的Numpy版本:1.6.1我的statsmodels版本:0.4.1我正在使用Windows.

我在这里查看文档,但无法弄清楚我做错了什么.我错过了什么？

提前致谢.

我想保留满足两个或多个条件的数组的值，例如：

a = np.array([1,3,5,6,4,6,7,8,9])

我只想保留大于 3 且小于 7 的值，我想要的输出是：

array([5, 6, 4, 6])

我看到一种方法：

a = a[(a > 3) * (a < 7)]  

但是这种乘法感觉有些多余，而且我认为我缺少一个内置的方法来处理这样的事情。

我想知道用稀疏矩阵替换不满足某个条件的行的最佳方法是什么.例如(我使用普通数组进行说明):

我想用一行零替换总和大于10的每一行

a = np.array([[0,0,0,1,1],
              [1,2,0,0,0],
              [6,7,4,1,0],  # sum > 10
              [0,1,1,0,1],
              [7,3,2,2,8],  # sum > 10 
              [0,1,0,1,2]])

我想用零替换[2]和[4],所以我的输出应该如下所示:

array([[0, 0, 0, 1, 1],
       [1, 2, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 1, 1, 0, 1],
       [0, 0, 0, 0, 0],
       [0, 1, 0, 1, 2]])

这对于密集矩阵来说非常简单:

row_sum = a.sum(axis=1)
to_keep = row_sum >= 10   
a[to_keep] = np.zeros(a.shape[1]) 

但是,当我尝试:

s = sparse.csr_matrix(a) 
s[to_keep, :] = np.zeros(a.shape[1])

我收到此错误:

    raise NotImplementedError("Fancy indexing in assignment not "
NotImplementedError: Fancy indexing …

编辑:性能的巨大差异是由于测试中的错误,正确设置时Eigen速度提高了2到3倍.

我注意到使用C++ Eigen库的稀疏矩阵乘法 比使用Python scipy.sparse库慢得多.我scipy.sparse在~0.03几秒钟内完成了我Eigen在~25几秒钟内取得的成就.也许我在Eigen做错了什么？

这里Python代码:

from scipy import sparse
from time import time
import random as rn

N_VALUES = 200000
N_ROWS = 400000
N_COLS = 400000

rows_a = rn.sample(range(N_COLS), N_VALUES)
cols_a = rn.sample(range(N_ROWS), N_VALUES)
values_a = [rn.uniform(0,1) for _ in xrange(N_VALUES)]

rows_b = rn.sample(range(N_COLS), N_VALUES)
cols_b = rn.sample(range(N_ROWS), N_VALUES)
values_b = [rn.uniform(0,1) for _ in xrange(N_VALUES)]

big_a = sparse.coo_matrix((values_a, (cols_a, rows_a)), shape=(N_ROWS, N_COLS))
big_b …

以下是我要看的内容:

In [1]: import sys

In [2]: sys.getsizeof(45)
Out[2]: 24

In [3]: sys.getsizeof([])
Out[3]: 72

In [4]: sys.getsizeof(range(1000))
Out[4]: 8072

我知道int在Python中可以增长(可以变大24个字节)对象,它们存在于堆上,我知道为什么该对象可能非常大,但不仅仅是这些对象的集合列表？显然它不是,这里发生了什么？

我试图将用户定义的函数应用于PySpark中的Window。我已经读过UDAF也许是要走的路，但是我找不到任何具体的东西。

举个例子（摘自：Xinh的技术博客，并针对PySpark进行了修改）：

from pyspark import SparkConf
from pyspark.sql import SparkSession
from pyspark.sql.window import Window
from pyspark.sql.functions import avg

spark = SparkSession.builder.master("local").config(conf=SparkConf()).getOrCreate()

a = spark.createDataFrame([[1, "a"], [2, "b"], [3, "c"], [4, "d"], [5, "e"]], ['ind', "state"])

customers = spark.createDataFrame([["Alice", "2016-05-01", 50.00],
                                    ["Alice", "2016-05-03", 45.00],
                                    ["Alice", "2016-05-04", 55.00],
                                    ["Bob", "2016-05-01", 25.00],
                                    ["Bob", "2016-05-04", 29.00],
                                    ["Bob", "2016-05-06", 27.00]],
                               ["name", "date", "amountSpent"])

customers.show()

window_spec = Window.partitionBy("name").orderBy("date").rowsBetween(-1, 1)

result = customers.withColumn( "movingAvg", avg(customers["amountSpent"]).over(window_spec))

result.show()

我正在应用avg已经内置的函数，pyspark.sql.functions但是如果avg我不想使用更复杂的函数并编写自己的函数，该怎么办？