小编che*_*ens的帖子

我有以下数据框：

id   total_transfered_amount day
1       1000                 2
1       2000                 3
1       3000                 4
1       1000                 1
1       10000                4
2       5000                 3
2       6000                 4
2       40000                2
2       4000                 3
2       4000                 3
3       1000                 1
3       2000                 2
3       3000                 3
3       30000                3
3       3000                 3

需要使用 dplyr 包preferabely分别为每个id过滤掉'total_transfered_amount'列中超过90个百分点的行，例如我需要过滤掉以下行：

2       40000                2
3       30000                3

我已经将图像作为数组读取:

import numpy as np
from scipy import misc
face1=misc.imread('face1.jpg')

face1尺寸是 (288, 352, 3)

我需要迭代每个像素并填充y训练集中的列我采取了以下方法:

Y_training = np.zeros([1,1],dtype=np.uint8)

for i in range(0, face1.shape[0]): # We go over rows number 
    for j in range(0, face1.shape[1]): # we go over columns number
        if np.array_equiv(face1[i,j],[255,255,255]):
           Y_training=np.vstack(([0], Y_training))#0 if blank
        else:
           Y_training=np.vstack(([1], Y_training))

b = len(Y_training)-1
Y_training = Y_training[:b]
np.shape(Y_training)`

Wall time: 2.57 s

因为我需要在大约2000个图像的上面的过程中做任何更快的方法,我们可以减少运行时间到毫秒或naonseconds

我有以下数据框：

id        day           total_amount
 1       2015-07-09         1000
 1       2015-10-22          100
 1       2015-11-12          200
 1       2015-11-27         2392
 1       2015-12-16          123
 7       2015-07-09          200
 7       2015-07-09         1000
 7       2015-08-27       100018
 7       2015-11-25         1000
 8       2015-08-27         1000
 8       2015-12-07        10000
 8       2016-01-18          796
 8       2016-03-31        10000
15       2015-09-10         1500
15       2015-09-30         1000

如果它们具有相同的 id 直到到达该 id 的最后一行，我需要在 day 列中减去每两个连续的时间，然后这次开始减去 day 列中的时间以获得新的 id，输出中类似于以下几行：

 1       2015-08-09         1000 2015-11-22 - 2015-08-09
 1       2015-11-22          100 2015-12-12 - 2015-11-22
 1       2015-12-12          200 2015-12-16 - 2015-12-12
 1       2015-12-16         2392 …

我有以下datadrame

user_id  var  qualified_date    loyal_date
  1       1      2017-01-17     2017-02-03
  2       1      2017-01-03     2017-01-13
  3       1      2017-01-11      NaT
  4       1       NaT            NaT
  5       1       NaT            NaT
  6       2      2017-01-15      2017-02-14
  7       2      2017-01-07      NaT
  8       2      2017-01-23      2017-02-18
  9       2      2017-01-25      NaT
  10      2      2017-01-11      2017-03-01

我需要通过'Var'中的值对此数据帧进行分组,然后计算每个'qualified_date'和'engaged_date'列的非缺失值的数量.我可以单独为每个列执行此操作并将它们手动放入数据框中,但我正在寻找一个groupby方法或类似的方法,我可以自动进入一个新的DF而不是'var'中的值作为索引和两列显示每个组的非缺失值的计数.

像这样

var  qualified_count loyal_count
 1       xx            xx
 2       xx            xx

我有以下数据帧:

sale_id      created_at
1               2016-05-28T05:53:31.042Z
2               2016-05-30T12:50:58.184Z
3               2016-05-23T10:22:18.858Z
4               2016-05-27T09:20:15.158Z
5               2016-05-21T08:30:17.337Z
6               2016-05-28T07:41:14.361Z

我需要添加一年周列,其中包含created_at列中每行的年份和周数:

sale_id      created_at                      year_week
1               2016-05-28T05:53:31.042Z       2016-21
2               2016-05-30T12:50:58.184Z       2016-22
3               2016-05-23T10:22:18.858Z       2016-21
4               2016-05-27T09:20:15.158Z       2016-21
5               2016-05-21T08:30:17.337Z       2016-20
6               2016-05-28T07:41:14.361Z       2016-21

我更喜欢一种可以轻松转移到pyspark的解决方案.

我有两个以下的Spark数据框:

sale_df:

|user_id|total_sale|
+-------+----------+
|      a|      1100|
|      b|      2100|
|      c|      3300|
|      d|      4400  

和target_df:

 user_id|personalized_target|
+-------+-------------------+
|      b|               1000|
|      c|               2000|
|      d|               3000|
|      e|               4000|
+-------+-------------------+

如何以输出方式加入它们:

user_id   total_sale   personalized_target
 a           1100            NA
 b           2100            1000
 c           3300            2000
 d           4400            4000
 e           NA              4000

我已经尝试了所有连接类型,但似乎单个连接无法生成所需的输出.

任何PySpark或SQL和HiveContext都可以提供帮助.

我有一个字符串数组:

  var z:Array[String] =Array("hand", "ball", "eye")

我想在z中的每个元素附加一个"s",

我是scala的新手,我可以附加's'来打印它们:

 z.foreach(arg =>println(arg +"s"))

但我正在寻找的是实际上改变z中的所有元素以获得's'.

我有以下数据框：

                        total_gross_profit
  first_day_week    var 
      Feb-06         1  45293.09
                     2  61949.54
      Feb-13         1  44634.72
                     2  34584.15
      Feb-20         1  43796.89
                     2  37308.57
      Feb-27         1  44136.21
                     2  38237.67
      Jan-16         1  74695.91
                     2  75702.02
      Jan-23         1  86101.05
                     2  69518.39
      Jan-30         1  65913.56
                     2  74823.94
      Mar-06         1  34256.47
                     2  31953.00

我按first_day_week和var列分组，我需要绘制一个条形图，其中我first_day_week在x轴上，对于first_day_week两个条形图中的每个条目，每个值var用不同的颜色表示，类似于（以下条形图的数据完全是假的）：

我在已经从Mysql DB导入的数据框中有以下列：

atst 
b'2017-01-17 01:50:00'
b'2017-01-17 01:50:00'
b'2017-01-17 01:50:00'

我需要将其转换为日期时间，我已经尝试过这种方法，但是将Nat放在了列中：

 df1['atst']=df['atst'].str.decode("utf-8")
 df1['atst']=pd.to_datetime(df1['atst'])

我将其解码为UTF-8的原因是，当我尝试不解码而将其转换时，出现以下错误：

Unknown string format

我有以下数据框，数据集已经从数据库表中导入，并且 created_at 列具有字符类型：

sale_id      created_at
1               2016-05-28T05:53:31.042Z
2               2016-05-30T12:50:58.184Z
3               2016-05-23T10:22:18.858Z
4               2016-05-27T09:20:15.158Z
5               2016-05-21T08:30:17.337Z
6               2016-05-28T07:41:14.361Z

如何从 created_at 列中仅提取小时和分钟，最好使用基本 r 库？我需要稍后将小时和分钟粘贴在一起并将其作为新列。

我有以下sparkdataframe：

id weekly_sale
1    40000
2    120000
3    135000
4    211000
5    215000
6    331000
7    337000

我需要查看weekly_sale列中以下哪些间隔项属于：

under 100000
between 100000 and 200000
between 200000 and 300000
more than 300000

所以我想要的输出将是：

id weekly_sale  label
1    40000       under 100000    
2    120000      between 100000 and 200000
3    135000      between 100000 and 200000
4    211000      between 200000 and 300000
5    215000      between 200000 and 300000
6    331000      more than 300000
7    337000      more than 300000

任何pyspark，spark.sql和Hive上下文实现都将对我有所帮助。