GVKun编程网logo

按2列分组并计算第3个数字列的分位数（按某列分组）

7

这篇文章主要围绕按2列分组并计算第3个数字列的分位数和按某列分组展开，旨在为您提供一份详细的参考资料。我们将全面介绍按2列分组并计算第3个数字列的分位数的优缺点，解答按某列分组的相关问题，同时也会为您

这篇文章主要围绕按2列分组并计算第3个数字列的分位数和按某列分组展开，旨在为您提供一份详细的参考资料。我们将全面介绍按2列分组并计算第3个数字列的分位数的优缺点，解答按某列分组的相关问题，同时也会为您带来C#计算一个数字的总位数、java按某属性分组并计算相关属性的和。、LINQ按多列分组(Group By)并计算总和(Sum) （转载）、MySQL：按连续天数分组并计数组的实用方法。

本文目录一览：

按2列分组并计算第3个数字列的分位数（按某列分组）

按2列分组并计算第3个数字列的分位数（按某列分组）

您可以尝试

p50 = df.groupby(['day','mealtype']).agg(p50 = ('oz',lambda x: x.quantile(0.5))).reset_index()
p90 = df.groupby(['day','mealtype']).agg(p90 = ('oz',lambda x: x.quantile(0.9))).reset_index()
new_df=p50.merge(p90,on=['day','mealtype'])
new_df

或

new_df = df.groupby(['day','mealtype'])['oz'].agg(p50 = (lambda x: x.quantile(0.5)),p90 = (lambda x: x.quantile(0.9))).reset_index()

输出 

     day    mealtype    p50     p90
0   Monday  Dinner      0.210   0.290
1   Monday  Snack       0.385   0.421
2   Sunday  Dinner      0.010   0.010
3   Sunday  Lunch       0.030   0.030
4   Sunday  Snack       0.330   0.330
5   Tuesday Breakfast   0.100   0.100
6   Tuesday Dinner      0.090   0.090
,

让我们尝试groupby().quantile()：

(df.groupby(['day','mealtype'])['oz']
   .quantile(q=[0.5,0.9])
   .unstack(level=-1)
   .rename(columns=lambda x: f'p{int(x*100)}') # rename columns
)

输出：

                     p50    p90
day     mealtype               
Monday  Dinner     0.210  0.290
        Snack      0.385  0.421
Sunday  Dinner     0.010  0.010
        Lunch      0.030  0.030
        Snack      0.330  0.330
Tuesday Breakfast  0.100  0.100
        Dinner     0.090  0.090

C#计算一个数字的总位数

C#计算一个数字的总位数

using System;

public class Demo {

public static void Main() {
   uint val = 12; // 1100 in binary
   uint res = (uint) Math.Log(val, 2.0) + 1;

   // 1100 has 4 bits
   Console.WriteLine(Total bits:  + res);
   }
}

java按某属性分组并计算相关属性的和。

java按某属性分组并计算相关属性的和。

工作中在处理集合的时候会经常遇到需要分组然后计算某属性的和，在java8中，通过stream来操作集合，还是非常方便的，像过滤（filter)、分组（group）、获取单个属性的值，总而言之，简单方便。也有人不推荐使用，觉得写的太多，可读性会变差，主要看个人喜好吧。

下面主要是处理分组求和的代码 一个商品实体类，添加一些计算属性

import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;

/**
 * @Auther: John.ma
 * @Description: 商品类型
 * @Date: 2019/5/17 13:51
 */
@Setter
@Getter
@ToString
@Accessors(chain = true)
public class Goods {

    /** 商品类型 */
    @ApiModelProperty(value = "商品类型")
    private String goodsType;

    /** 备件名称 */
    @ApiModelProperty(value = "备件名称")
    private String goodsName;

    /** 供应商 */
    @ApiModelProperty(value = "供应商")
    private String supplier;

    /** 一个月预测 */
    @ApiModelProperty(value = "一个月预测")
    private Integer oneMonthCount;

    /** 三个月预测 */
    @ApiModelProperty(value = "三个月预测")
    private Integer threeMonthCount;

    /** 半年预测 */
    @ApiModelProperty(value = "半年预测")
    private Integer sixMonthCount;

    @ApiModelProperty(value = "数量")
    private Integer count;
}

一个测试方法

    public static void group() {
        List<Goods> stockGoodsVOS = Lists.newArrayList();
        Goods vo = new Goods();
        Goods vo1 = new Goods();
        Goods vo2 = new Goods();
        Goods vo3 = new Goods();
        vo.setGoodsType("a").setGoodsName("test").setSupplier("a").setOneMonthCount(10)
                                           .setThreeMonthCount(20).setSixMonthCount(15).setCount(5);
        vo1.setGoodsType("b").setGoodsName("testa").setSupplier("b").setOneMonthCount(5)
                                            .setThreeMonthCount(5).setSixMonthCount(5).setCount(5);
        vo2.setGoodsType("c").setGoodsName("testa").setSupplier("b").setOneMonthCount(1)
                                            .setThreeMonthCount(1).setSixMonthCount(1).setCount(1);
        vo3.setGoodsType("c").setGoodsName("testa").setSupplier("b").setOneMonthCount(1)
                                            .setThreeMonthCount(1).setSixMonthCount(1).setCount(1);
        stockGoodsVOS.add(vo);
        stockGoodsVOS.add(vo1);
        stockGoodsVOS.add(vo2);
        stockGoodsVOS.add(vo3);
        List<Goods> goodsVOS = Lists.newArrayList();
        //主要代码
        stockGoodsVOS.stream()
                .collect(Collectors.groupingBy(Goods::getGoodsType))
                .forEach((k, v) -> {
                    Optional<Goods> reduce = v.stream().reduce((v1, v2) -> {
                        v1.setOneMonthCount(BigDecimal.valueOf(v1.getOneMonthCount())
                                    .add(BigDecimal.valueOf(v2.getOneMonthCount())).intValue());
                        v1.setThreeMonthCount(BigDecimal.valueOf(v1.getThreeMonthCount())
                                    .add(BigDecimal.valueOf(v2.getThreeMonthCount())).intValue());
                        v1.setSixMonthCount(BigDecimal.valueOf(v1.getSixMonthCount())
                                    .add(BigDecimal.valueOf(v2.getSixMonthCount())).intValue());
                        return v1;
                    });
                    goodsVOS.add(reduce.get());
                });
        
        goodsVOS.forEach(vos -> {
            System.out.println(vos);
        });
    }

运行结果

小结

工作记录。

LINQ按多列分组(Group By)并计算总和(Sum) （转载）

LINQ按多列分组(Group By)并计算总和(Sum) （转载）

.NET[C#]LINQ按多列分组(Group By)并计算总和(Sum)

SQL语句：

SELECT * FROM <TableName> GROUP BY <Column1>,<Column2>
QuantityBreakdown
(
    MaterialID int,
    ProductID int,
    Quantity float
)

INSERT INTO @QuantityBreakdown (MaterialID, ProductID, Quantity)
SELECT MaterialID, ProductID, SUM(Quantity)
FROM @Transactions
GROUP BY MaterialID, ProductID
在C#中，如何使用LINQ实现以上SQL语句中的需求呢？方式归纳如下：

方式一
var query = (from t in Transactions
             group t by new {t.MaterialID, t.ProductID}
             into grp
                    select new
                    {
                        grp.Key.MaterialID,
                        grp.Key.ProductID,
                        Quantity = grp.Sum(t => t.Quantity)
                    }).ToList();
方式二
from grouping in list.GroupBy(x => new Tuple<string,string,string>(x.Person.LastName,x.Person.FirstName,x.Person.MiddleName))
select new SummaryItem
{
    LastName = grouping.Key.Item1,
    FirstName = grouping.Key.Item2,
    MiddleName = grouping.Key.Item3,
    DayCount = grouping.Count(), 
    AmountBilled = grouping.Sum(x => x.Rate),
}
方式三
var Results= query.GroupBy(x => new { x.Column1, x.Column2 });

 

易错提醒：

grp.Key.ProductID, //前往不要忘了Key！！！
Quantity = grp.Sum(t => t.Quantity) //必须取别名Quantity ！！！

 

MySQL：按连续天数分组并计数组

MySQL：按连续天数分组并计数组

有一个数据库表，其中包含每个用户在城市中的签到记录。我需要知道一个用户在一个城市呆了多少天，然后，一个用户对一个城市进行了多少次访问（一次访问包括在一个城市连续逗留的天数）。

所以，考虑我有下表（简化，只包含DATETIMEs - 相同的用户和城市）：

      datetime-------------------2011-06-30 12:11:462011-07-01 13:16:342011-07-01 15:22:452011-07-01 22:35:002011-07-02 13:45:122011-08-01 00:11:452011-08-05 17:14:342011-08-05 18:11:462011-08-06 20:22:12

该用户到过这个城市的天数为6 ( 30.06 , 01.07 , 02.07 , 01.08 , 05.08 , 06.08 )。

我想这样做使用 SELECT COUNT(id) FROM table GROUP BY DATE(datetime)

然后，对于该用户对该城市的访问次数，查询应返回3 ( 30.06-02.07 , 01.08 , 05.08-06.08 )。

问题是我不知道如何构建这个查询。

任何帮助将不胜感激！

答案1

小编典典

您可以通过查找前一天没有签到的签到来找到每次访问的第一天。

select count(distinct date(start_of_visit.datetime))from checkin start_of_visitleft join checkin previous_day    on start_of_visit.user = previous_day.user    and start_of_visit.city = previous_day.city    and date(start_of_visit.datetime) - interval 1 day = date(previous_day.datetime)where previous_day.id is null

此查询有几个重要部分。

首先，每个签入都与前一天的任何签入相结合。但由于它是外部联接，如果前一天没有签入，联接的右侧将有NULL结果。该WHERE过滤发生在加盟之后，所以只保留那些签入从左侧那里有从右侧无。 LEFT OUTER JOIN/WHERE IS NULL对于发现那里的东西非常方便不是。

然后它会计算不同的签到日期，以确保如果用户在访问的第一天多次签到，它不会重复计算。（当我发现可能的错误时，我实际上在编辑时添加了该部分。）

编辑：我刚刚重新阅读了您针对第一个问题提出的查询。您的查询将获得给定日期的签到次数，而不是日期计数。我认为你想要这样的东西：

select count(distinct date(datetime))from checkinwhere user=''some user'' and city=''some city''

关于按2列分组并计算第3个数字列的分位数和按某列分组的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于C#计算一个数字的总位数、java按某属性分组并计算相关属性的和。、LINQ按多列分组(Group By)并计算总和(Sum) （转载）、MySQL：按连续天数分组并计数组的相关知识，请在本站寻找。

本文标签：

上一篇TestCafe：如果用户从另一台计算机登录，如何测试注销

下一篇如何将从先前算法中获得的多个数值添加到数组中，以便在MU python编辑器中进行微位计算？

相关文章