本文将分享groupby和count如何在sql中工作的详细内容，并且还将对groupby在sql语句中如何使用进行详尽解释，此外，我们还将为大家带来关于.net–使用GROUPBY和Count(*)
本文将分享groupby和count如何在sql中工作的详细内容，并且还将对group by在sql语句中如何使用进行详尽解释，此外，我们还将为大家带来关于.net – 使用GROUP BY和Count(*)进行匿名类型的LINQ查询、as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别、groupby 的妙用（注意size和count）、groupby是什么意思在sql中的相关知识，希望对你有所帮助。
本文目录一览：- groupby和count如何在sql中工作（group by在sql语句中如何使用）
- .net – 使用GROUP BY和Count(*)进行匿名类型的LINQ查询
- as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别
- groupby 的妙用（注意size和count）
- groupby是什么意思在sql中
groupby和count如何在sql中工作（group by在sql语句中如何使用）
1> select browser,count(*) from logtest group by browser;
+-----------+----------+| browser | count(*) |+-----------+----------+| Firefox 3 | 14 || Unknown | 11 |+-----------+----------+套装2排
2> select browser,count(browser) from logtest group by browser;
+-----------+----------------+| browser | count(browser) |+-----------+----------------+| Firefox 3 | 14 || Unknown | 11 |+-----------+----------------+套装2排
3> select browser,count(browser) from logtest;
+-----------+----------------+| browser | count(browser) |+-----------+----------------+| Firefox 3 | 25 |+-----------+----------------+一组1行
为什么查询方式1>和2>会得到相同的结果？count（*）和count（somefiled）之间没有什么区别？
另外，查询2>和3>导致的结果不同，为什么 groupby 如此神奇？它是如何工作的？
更新：我正在使用MySQL5.1。:)
答案1
小编典典选择会给您一个结果集。如果按字段分组选择，则结果集的行将按该字段分组，并且结果集的每一行将特定于结果组。
例如，您有一个名为Animals的表，其中包含以下字段：
Type | Gender | Name如果您正在运行此查询（例如在MySQL中）：
select Type, Gender, Name from Animals where Type <> ''Pig''您会得到所有不是“猪”的动物。如果某行的Type =’pig’，则该行将包含在结果中。
该查询：
select Type, Gender, count(*) from Animals group by Type, Gender将有这么多行：类型数*性别数
您可以通过使用MySQL中的hading子句为您的组创建条件。
在这里阅读更多
count(*)和之间的区别count(browser)是，第一个将返回所有记录的数量，第二个将返回其中的所有记录的数量not (browseris null)。
尝试在其中插入一行，browser is null然后运行1）和2），这是最好的测试。
.net – 使用GROUP BY和Count(*)进行匿名类型的LINQ查询
假设我有一些看起来像这样的数据(实际上有一些对象暴露了这个属性,但它的工作原理相同)
GroupId 1 1 2 2 2 3
我知道如何在sql中格式化我的查询.它会是这样的：
SELECT grp = GroupId,cnt = COUNT(*) FROM myTable GROUP BY GroupId
在这种情况下,输出将类似于this SQL Fiddle：
GroupID Count 1 2 2 3 3 1
如何在vb.net中使用LINQ做同样的事情
Dim groupCounts = From person In data
Group By person.GroupId
Select new {group = person.GroupId,count = count(*)}
这不太对,但我认为它很接近.
另外,我不太了解匿名类型,我是否可以提前声明groupCounts它是一个枚举项目,每个项目都有一个group和count属性？
Public Sub grouper2()
Dim numbers = New Integer() {1,1,2,3}
Dim numberGroups = From w In numbers _
Group w By Key = w Into Group _
Select Number = Key,numbersCount = Group.Count()
'linqpad specific output
'numberGroups.Dump()
For Each g In numberGroups
Console.WriteLine("Numbers that match '{0}':",g.Number)
Console.WriteLine(g.numbersCount)
Next
End Sub
as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别
编辑： 我在np.nan@ coldspeed，@ wen-ben，@
ALollz指出的字符串中犯的菜鸟错误。答案非常好，因此我不会删除此问题以保留这些答案。
原文：
我已经阅读了这个问题/答案[groupby.first（）和groupby.head（1）有什么区别？
该答案说明差异在于处理NaN价值上。但是，当我打电话给groupby时as_index=False，他们俩都选择了NaN。
此外，Pandas具有groupby.nth与和类似的功能head，并且first
有什么差异groupby.first(), groupby.nth(0), groupby.head(1)有as_index=False？
下面的例子：
In [448]: dfOut[448]: A B0 1 np.nan1 1 42 1 143 2 84 2 195 2 12In [449]: df.groupby(''A'', as_index=False).head(1)Out[449]: A B0 1 np.nan3 2 8In [450]: df.groupby(''A'', as_index=False).first()Out[450]: A B0 1 np.nan1 2 8In [451]: df.groupby(''A'', as_index=False).nth(0)Out[451]: A B0 1 np.nan3 2 8我看到`firs（）’重置了索引，而其他2则没有。除此之外，还有什么区别吗？
答案1
小编典典主要问题是您可能''np.nan''存储了字符串，而不是真正的null值。以下是这三个null值的不同处理方式：
样本数据：
import pandas as pddf = pd.DataFrame({''A'': [1,1,2,2,3,3], ''B'': [None, ''1'', np.NaN, ''2'', 3, 4]})first
这将返回每个组中的第一个非空值。奇怪的是它不会跳过None，尽管可以通过kwarg来实现dropna=True。因此，
您可能会返回原来属于不同行的列的值 ：
df.groupby(''A'', as_index=False).first()# A B#0 1 None#1 2 2#2 3 3df.groupby(''A'', as_index=False).first(dropna=True)# A B#0 1 1#1 2 2#2 3 3head(n)
返回组中的前n行。 值保持在行内 。如果您给它的n行数超过了行数，它将返回该组中的所有行而不会抱怨：
df.groupby(''A'', as_index=False).head(1)# A B#0 1 None#2 2 NaN#4 3 3df.groupby(''A'', as_index=False).head(200)# A B#0 1 None#1 1 1#2 2 NaN#3 2 2#4 3 3#5 3 4nth：
这占用了nth行，因此 值 再次 保持在row内
。.nth(0)与相同.head(1)，但用途不同。例如，如果您需要第0行和第2行，则很难做到.head()，而使用则容易.nth([0,2])。同样，它.head(10)比容易编写.nth(list(range(10))))。
df.groupby(''A'', as_index=False).nth(0)# A B#0 1 None#2 2 NaN#4 3 3nth 还支持删除具有任何空值的行，因此您可以使用它返回不包含任何空值的第一行，这与 .head()
df.groupby(''A'', as_index=False).nth(0, dropna=''any'')# A B#A #1 1 1#2 2 2#3 3 3
groupby 的妙用（注意size和count）
Pandas的groupby()功能很强大，用好了可以方便的解决很多问题，在数据处理以及日常工作中经常能施展拳脚。
今天，我们一起来领略下groupby()的魅力吧。
首先，引入相关package：
import pandas as pd import numpy as np
groupby的基础操作
df = pd.DataFrame({''A'': [''a'', ''b'', ''a'', ''c'', ''a'', ''c'', ''b'', ''c''],
...: ''B'': [2, 8, 1, 4, 3, 2, 5, 9],
...: ''C'': [102, 98, 107, 104, 115, 87, 92, 123]})
...: df
...:
Out[2]:
A B C
0 a 2 102
1 b 8 98
2 a 1 107
3 c 4 104
4 a 3 115
5 c 2 87
6 b 5 92
7 c 9 123按A列分组（groupby），获取其他列的均值
df.groupby(''A'').mean()
Out[3]:
B C
A
a 2.0 108.000000
b 6.5 95.000000
c 5.0 104.666667按多列进行分组（groupby）
df.groupby([''A'',''B'']).mean()
Out[4]:
C
A B
a 1 107
2 102
3 115
b 5 92
8 98
c 2 87
4 104
9 123分组后选择列进行运算
In [5]: df = pd.DataFrame([[1, 1, 2], [1, 2, 3], [2, 3, 4]], columns=["A", "B", "C"])
...: df
...:
Out[5]:
A B C
0 1 1 2
1 1 2 3
2 2 3 4
In [6]: g = df.groupby("A")
In [7]: g[''B''].mean() # 仅选择B列
Out[7]:
A
1 1.5
2 3.0
Name: B, dtype: float64
In [8]: g[[''B'', ''C'']].mean() # 选择B、C列
Out[8]:
B C
A
1 1.5 2.5
2 3.0 4.0可以针对不同的列选用不同的聚合方法
In [9]: g.agg({''B'':''mean'', ''C'':''sum''})
Out[9]:
B C
A
1 1.5 5
2 3.0 4聚合方法size()和count()
size跟count的区别： size计数时包含NaN值，而count不包含NaN值
In [10]: df = pd.DataFrame({"Name":["Alice", "Bob", "Mallory", "Mallory", "Bob" , "Mallory"],
...: "City":["Seattle", "Seattle", "Portland", "Seattle", "Seattle", "Portland"],
...: "Val":[4,3,3,np.nan,np.nan,4]})
...:
...: df
...:
Out[10]:
City Name Val
0 Seattle Alice 4.0
1 Seattle Bob 3.0
2 Portland Mallory 3.0
3 Seattle Mallory NaN
4 Seattle Bob NaN
5 Portland Mallory 4.0count()
In [11]: df.groupby(["Name", "City"], as_index=False)[''Val''].count()
Out[11]:
Name City Val
0 Alice Seattle 1
1 Bob Seattle 1
2 Mallory Portland 2
3 Mallory Seattle 0size()
In [12]: df.groupby(["Name", "City"])[''Val''].size().reset_index(name=''Size'')
Out[12]:
Name City Size
0 Alice Seattle 1
1 Bob Seattle 2
2 Mallory Portland 2
3 Mallory Seattle 1分组运算方法 agg()
In [13]: df = pd.DataFrame({''A'': list(''XYZXYZXYZX''), ''B'': [1, 2, 1, 3, 1, 2, 3, 3, 1, 2],
...: ''C'': [12, 14, 11, 12, 13, 14, 16, 12, 10, 19]})
...: df
...:
Out[13]:
A B C
0 X 1 12
1 Y 2 14
2 Z 1 11
3 X 3 12
4 Y 1 13
5 Z 2 14
6 X 3 16
7 Y 3 12
8 Z 1 10
9 X 2 19
In [14]: df.groupby(''A'')[''B''].agg({''mean'':np.mean, ''standard deviation'': np.std})
Out[14]:
mean standard deviation
A
X 2.250000 0.957427
Y 2.000000 1.000000
Z 1.333333 0.577350针对不同的列应用多种不同的统计方法
In [15]: df.groupby(''A'').agg({''B'':[np.mean, ''sum''], ''C'':[''count'',np.std]})
Out[15]:
B C
mean sum count std
A
X 2.250000 9 4 3.403430
Y 2.000000 6 3 1.000000
Z 1.333333 4 3 2.081666分组运算方法 apply()
In [16]: df = pd.DataFrame({''A'': list(''XYZXYZXYZX''), ''B'': [1, 2, 1, 3, 1, 2, 3, 3, 1, 2],
...: ''C'': [12, 14, 11, 12, 13, 14, 16, 12, 10, 19]})
...: df
...:
Out[16]:
A B C
0 X 1 12
1 Y 2 14
2 Z 1 11
3 X 3 12
4 Y 1 13
5 Z 2 14
6 X 3 16
7 Y 3 12
8 Z 1 10
9 X 2 19
In [17]: df.groupby(''A'').apply(np.mean)
...: # 跟下面的方法的运行结果是一致的
...: # df.groupby(''A'').mean()
Out[17]:
B C
A
X 2.250000 14.750000
Y 2.000000 13.000000
Z 1.333333 11.666667apply()方法可以应用lambda函数，举例如下:
In [18]: df.groupby(''A'').apply(lambda x: x[''C'']-x[''B''])
Out[18]:
A
X 0 11
3 9
6 13
9 17
Y 1 12
4 12
7 9
Z 2 10
5 12
8 9
dtype: int64
In [19]: df.groupby(''A'').apply(lambda x: (x[''C'']-x[''B'']).mean())
Out[19]:
A
X 12.500000
Y 11.000000
Z 10.333333
dtype: float64分组运算方法 transform()
前面进行聚合运算的时候，得到的结果是一个以分组名为 index 的结果对象。如果我们想使用原数组的 index 的话，就需要进行 merge 转换。transform(func, args, *kwargs) 方法简化了这个过程，它会把 func 参数应用到所有分组，然后把结果放置到原数组的 index 上（如果结果是一个标量，就进行广播）：
In [20]: df = pd.DataFrame({''group1'' : [''A'', ''A'', ''A'', ''A'',
...: ''B'', ''B'', ''B'', ''B''],
...: ''group2'' : [''C'', ''C'', ''C'', ''D'',
...: ''E'', ''E'', ''F'', ''F''],
...: ''B'' : [''one'', np.NaN, np.NaN, np.NaN,
...: np.NaN, ''two'', np.NaN, np.NaN],
...: ''C'' : [np.NaN, 1, np.NaN, np.NaN,
...: np.NaN, np.NaN, np.NaN, 4]})
...: df
...:
Out[20]:
B C group1 group2
0 one NaN A C
1 NaN 1.0 A C
2 NaN NaN A C
3 NaN NaN A D
4 NaN NaN B E
5 two NaN B E
6 NaN NaN B F
7 NaN 4.0 B F
In [21]: df.groupby([''group1'', ''group2''])[''B''].transform(''count'')
Out[21]:
0 1
1 1
2 1
3 0
4 1
5 1
6 0
7 0
Name: B, dtype: int64
In [22]: df[''count_B'']=df.groupby([''group1'', ''group2''])[''B''].transform(''count'')
...: df
...:
Out[22]:
B C group1 group2 count_B
0 one NaN A C 1
1 NaN 1.0 A C 1
2 NaN NaN A C 1
3 NaN NaN A D 0
4 NaN NaN B E 1
5 two NaN B E 1
6 NaN NaN B F 0
7 NaN 4.0 B F 0上面运算的结果分析： {‘group1’:’A’, ‘group2’:’C’}的组合共出现3次，即index为0,1,2。对应”B”列的值分别是”one”,”NaN”,”NaN”，由于count()计数时不包括Nan值，因此{‘group1’:’A’, ‘group2’:’C’}的count计数值为1。
transform()方法会将该计数值在dataframe中所有涉及的rows都显示出来（我理解应该就进行广播）
将某列数据按数据值分成不同范围段进行分组（groupby）运算
In [23]: np.random.seed(0)
...: df = pd.DataFrame({''Age'': np.random.randint(20, 70, 100),
...: ''Sex'': np.random.choice([''Male'', ''Female''], 100),
...: ''number_of_foo'': np.random.randint(1, 20, 100)})
...: df.head()
...:
Out[23]:
Age Sex number_of_foo
0 64 Female 14
1 67 Female 14
2 20 Female 12
3 23 Male 17
4 23 Female 15
groupby是什么意思在sql中
group by 是 sql 中用于分组和聚合数据的语句。它按分组键将行分组，然后应用聚合函数，例如计算总和、计数或平均值。
GROUP BY 在 SQL 中的含义
GROUP BY 是 SQL 中的一条语句，用于将数据集中的行分组并聚合相同组中的数据。
工作原理
GROUP BY 语句接受一个或多个分组键作为参数。这些键是数据集中的列，用于确定将哪些行分组在一起。
分组后，SQL 会针对每个组执行
- SUM：计算组中某列的总和
- COUNT：计算组中行的数量
- AVG：计算组中某列的平均值
- MIN：查找组中某列的最小值
- MAX：查找组中某列的最大值
语法
GROUP BY 语句的语法如下：
SELECT () FROM GROUP BY
示例
以下示例计算每个产品类别的销售额总和：
SELECT SUM(Sales) FROM Sales GROUP BY ProductCategory
该查询将返回一个包含每个产品类别及其相应销售额总和的新数据集。
以上就是groupby是什么意思在sql中的详细内容，更多请关注php中文网其它相关文章！
关于groupby和count如何在sql中工作和group by在sql语句中如何使用的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于.net – 使用GROUP BY和Count(*)进行匿名类型的LINQ查询、as_index = False时，groupby.first，groupby.nth，groupby.head有什么区别、groupby 的妙用（注意size和count）、groupby是什么意思在sql中的相关知识，请在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
