AI 助理
备案控制台
开发者社区 大数据 文章 正文

数据分析之pandas常见的数据处理(四)

2018-07-13 1593
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 常见聚合方法方法 说明count 计数describe 给出各列的常用统计量min,max 最大最小值argmin,argmax 最大最小值的索引位置（整数）idx...

常见聚合方法

方法 说明
count 计数
describe 给出各列的常用统计量
min,max 最大最小值
argmin,argmax 最大最小值的索引位置（整数）
idxmin,idxmax 最大最小值的索引值
quantile 计算样本分位数
sum,mean 对列求和，均值
mediam 中位数
mad 根据平均值计算平均绝对离差
var,std 方差，标准差
skew 偏度（三阶矩）
Kurt 峰度（四阶矩）
cumsum 累积和
Cummins，cummax 累计组大致和累计最小值
cumprod 累计积
diff 一阶差分
pct_change 计算百分数变化

1 清洗无效数据

df[df.isnull()]  #判断是够是Nan,None返回的是个true或false的Series对象
df[df.notnull()]

#dropna(): 过滤丢失数据
#df3.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
df.dropna()                 #将所有含有nan项的row删除
df.dropna(axis=1,thresh=3)  #将在列的方向上三个为NaN的项删除
df.dropna(how='ALL')        #将全部项都是nan的row删除

df.dropna()与data[data.notnull()]  #效果一致

#fillna(): 填充丢失数据
#前置填充  axis = 0 行
#后置填充  axis = 1 列
df3.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
df.fillna({1:0, 2:0.5})         #对第一列nan值赋0，第二列赋值0.5
df.fillna(method='ffill')   #在列方向上以前一个值作为值赋给NaN

2 drop函数使用

drop函数的使用：删除行、删除列
print frame.drop(['a'])
print frame.drop(['Ohio'], axis = 1)

drop函数默认删除行，列需要加axis = 1

drop函数的使用：inplace参数

采用drop方法，有下面三种等价的表达式：

1. DF= DF.drop('column_name', axis=1)；
2. DF.drop('column_name',axis=1, inplace=True)
3. DF.drop([DF.columns[[0,1, 3]]], axis=1, inplace=True)

注意：凡是会对原数组作出修改并返回一个新数组的，往往都有一个 inplace可选参数。如果手动设定为True（默认为False），那么原数组直接就被替换。也就是说，采用inplace=True之后，原数组名（如2和3情况所示）对应的内存值直接改变；

而采用inplace=False之后，原数组名对应的内存值并不改变，需要将新的结果赋给一个新的数组或者覆盖原数组的内存位置（如1情况所示）。

drop函数的使用：数据类型转换
df['Name'] = df['Name'].astype(np.datetime64)

DataFrame.astype() 方法可对整个DataFrame或某一列进行数据格式转换，支持Python和NumPy的数据类型。

3 pandas数据处理方法

(1) 删除重复数据

df.duplicated() 返回boolean列表,重复为True

df.drop_duplicates() 删除重复元素即值为True的列行

参数列表

  • subset : column label or sequence of labels, optional
    用来指定特定的列，默认所有列
  • keep : {‘first’, ‘last’, False}, default ‘first’
    删除重复项并保留第一次出现的项
  • inplace : boolean, default False
    是直接在原来数据上修改还是保留一个副本
# 判断是否重复
data.duplicated()`
#移除重复数据
data.drop_duplicated()
#对指定列判断是否存在重复值，然后删除重复数据
data.drop_duplicated(['key1'])

df = DataFrame({'color':['white','white','red','red','white'],
               'value':[2,1,3,3,2]})
display(df,df.duplicated(),df.drop_duplicates())

#输出:
color   value
0   white   2
1   white   1
2   red 3
3   red 3
4   white   2
0    False
1    False
2    False
3     True
4     True
dtype: bool
color   value
0   white   2
1   white   1
2   red     3

(2) 映射

1 replace() 替换元素 replace({索引键值对})

df = DataFrame({'item':['ball','mug','pen'],
               'color':['white','rosso','verde'],
               'price':[5.56,4.20,1.30]})
newcolors = {'rosso':'red','verde':'green'}
display(df,df.replace(newcolors))

#输出：
    color   item    price
0   white   ball    5.56
1   rosso   mug 4.20
2   verde   pen 1.30
    color   item    price
0   white   ball    5.56
1   red mug 4.20
2   green   pen 1.30

2.replace还经常用来替换NaN元素

df2 = DataFrame({'math':[100,139,np.nan],'English':[146,None,119]},index = ['张三','李四','Tom'])
newvalues = {np.nan:100}
display(df2,df2.replace(newvalues))

#输出：
    English math
张三  146.0   100.0
李四  NaN 139.0
Tom 119.0   NaN
English math
张三  146.0   100.0
李四  100.0   139.0
Tom 119.0   100.0

2 map()函数：新建一列

map(函数,可迭代对象) map(函数/{索引键值对})

map中返回的数据是一个具体值，不能迭代.

df3 = DataFrame({'color':['red','green','blue'],'project':['math','english','chemistry']})
price = {'red':5.56,'green':3.14,'chemistry':2.79}
df3['price'] = df3['color'].map(price)
display(df3)

#输出：
color   project price
0   red     math        5.56
1   green   english     3.14
2   blue    chemistry   NaN


df3 = DataFrame({'zs':[129,130,34],'ls':[136,98,8]},index = ['张三','李四','倩倩'])
display(df3)
display(df3['zs'].map({129:'你好',130:'非常好',34:'不错'}))
display(df3['zs'].map({129:120}))
def mapscore(score):
    if score<90:
        return 'failed'
    elif score>120:
        return 'excellent'
    else:
        return 'pass'
df3['status'] = ddd['zs'].map(mapscore)
df3

输出：
      zs  ls
张三  129 136
李四  130 98
倩倩  34  8

张三     你好
李四    非常好
倩倩     不错
Name: zs, dtype: object

张三    120.0
李四      NaN
倩倩      NaN
Name: zs, dtype: float64
Out[96]:
ls    zs    status
张三  136 129 excellent
李四  98  130 excellent
倩倩  8   34  failed

3 rename()函数：替换索引 rename({索引键值对})

df4 = DataFrame({'color':['white','gray','purple','blue','green'],'value':np.random.randint(10,size = 5)})
new_index = {0:'first',1:'two',2:'three',3:'four',4:'five'}
display(df4,df4.rename(new_index))

#输出：
    color   value
0   white   2
1   gray    0
2   purple  9
3   blue    2
4   green   0
color   value
first   white   2
two     gray    0
three   purple  9
four    blue    2
five    green   0

(3) 异常值检测与过滤

1 使用describe()函数查看每一列的描述性统计量

df = DataFrame(np.random.randint(10,size = 10))
display(df.describe())      
        0
count   10.000000
mean    5.900000
std 2.685351
min 1.000000
25% 6.000000
50% 7.000000
75% 7.750000
max 8.000000

2 使用std()函数可以求得DataFrame对象每一列的标准差

df.std()

#输出：
0    3.306559
dtype: float64

3 根据每一列的标准差，对DataFrame元素进行过滤。
借助any()函数，对每一列应用筛选条件,any过滤出所有符合条件的数据

display(df[(df>df.std()*3).any(axis = 1)])
df.drop(df[(np.abs(df) > (3*df.std())).any(axis=1)].index,inplace=True)
display(df,df.shape)

输出：
    0   1
2   7   9
6   8   8
9   8   1
0   1
0   5   0
1   3   3
3   3   5
4   2   4
5   7   6
7   1   6
8   7   7
(7, 2)

(4) 排序

使用take()函数排序
可以借助np.random.permutation()函数随机排序

df5 = DataFrame(np.arange(25).reshape(5,5))
new_order = np.random.permutation(5)
display(new_order)
display(df5,df5.take(new_order))

#输出
array([4, 2, 3, 1, 0])
    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2   10  11  12  13  14
3   15  16  17  18  19
4   20  21  22  23  24
    0   1   2   3   4
4   20  21  22  23  24
2   10  11  12  13  14
3   15  16  17  18  19
1   5   6   7   8   9
0   0   1   2   3   4

(5) 数据分类分组

groupby()函数 

import pandas as pd
df = pd.DataFrame([{'col1':'a', 'col2':1, 'col3':'aa'}, {'col1':'b', 'col2':2, 'col3':'bb'}, {'col1':'c', 'col2':3, 'col3':'cc'}, {'col1':'a', 'col2':44, 'col3':'aa'}])
display(df)
# 按col1分组并按col2求和
display(df.groupby(by='col1').agg({'col2':sum}).reset_index())
# 按col1分组并按col2求最值
display(df.groupby(by='col1').agg({'col2':['max', 'min']}).reset_index())
# 按col1 ，col3分组并按col2求和
display(df.groupby(by=['col1', 'col3']).agg({'col2':sum}).reset_index())
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from datetime import datetime
'''
分组groupby
'''
df=pd.DataFrame({'key1':['a','a','b','b','a'],
                 'key2':['one','two','one','two','one'],
                 'data1':np.arange(5),
                 'data2':np.arange(5)})
print(df)
#   key1 key2  data1  data2
# 0    a  one      0      0
# 1    a  two      1      1
# 2    b  one      2      2
# 3    b  two      3      3
# 4    a  one      4      4

'''
根据分组进行计算
'''
#按key1分组,计算data1的平均值
grouped=df['data1'].groupby(df['key1'])
print(grouped.mean())
# a    1.666667
# b    2.500000

#按key1和key2分组，计算data1的平均值
groupedmean=df['data1'].groupby([df['key1'],df['key2']]).mean()
print(groupedmean)
# key1  key2
# a     one     2
#       two     1
# b     one     2
#       two     3

#列变行
print(groupedmean.unstack())
# key2  one  two
# key1
# a       2    1
# b       2    3

df['key1']#获取出来的数据series数据

#groupby分组键可以是series还可以是数组
states=np.array(['Oh','Ca','Ca','Oh','Oh'])
years=np.array([2005,2005,2006,2005,2006])
print(df['data1'].groupby([states,years]).mean())
# Ca  2005    1.0
#     2006    2.0
# Oh  2005    1.5
#     2006    4.0

#直接将列名进行分组，非数据项不在其中，非数据项会自动排除分组
print(df.groupby('key1').mean())
#          data1     data2
# key1
# a     1.666667  1.666667
# b     2.500000  2.500000

#将入key2分组
print(df.groupby(['key1','key2']).mean())
#            data1  data2
# key1 key2
# a    one       2      2
#      two       1      1
# b    one       2      2
#      two       3      3

#size()方法，返回含有分组大小的Series，得到分组的数量
print(df.groupby(['key1','key2']).size())
# key1  key2
# a     one     2
#       two     1
# b     one     1
#       two     1

'''
对分组信息进行迭代
'''

#将a,b进行分组
for name,group in df.groupby('key1'):
    print(name)
    print(group)
# a
#   key1 key2  data1  data2
# 0    a  one      0      0
# 1    a  two      1      1
# 4    a  one      4      4
# b
#   key1 key2  data1  data2
# 2    b  one      2      2
# 3    b  two      3      3

#根据多个建进行分组
for (k1,k2),group in df.groupby(['key1','key2']):
    print(name)
    print(group)
#  key1 key2  data1  data2
# 0    a  one      0      0
# 4    a  one      4      4
# b
#   key1 key2  data1  data2
# 1    a  two      1      1
# b
#   key1 key2  data1  data2
# 2    b  one      2      2
# b
#   key1 key2  data1  data2
# 3    b  two      3      3


'''
选取一个或一组列，返回的Series的分组对象
'''
#对于groupBy对象，如果用一个或一组列名进行索引。就会聚合
print(df.groupby(df['key1'])['data1'])#根据key1分组，生成data1的数据


print(df.groupby(['key1'])[['data1','data2']].mean())#根据key1分组，生成data1，data2的数据
#        data1     data2
# key1
# a     1.666667  1.666667
# b     2.500000  2.500000

print(df.groupby(['key1','key2'])['data1'].mean())
# key1  key2
# a     one     2
#       two     1
# b     one     2
#       two     3


'''
通过函数进行分组
'''
#加入你能根据人名长度进行分组的话，就直接传入len函数

print(people.groupby(len,axis=1).sum())#杭州3是三个字母
#       2     3
# a  30.0  20.0
# b  23.0  21.0
# c  26.0  22.0
# d  42.0  23.0
# e  46.0  24.0

#还可以和数组、字典、列表、Series混合使用
key_list=['one','one','one','two','two']
print(people.groupby([len,key_list],axis=1).min())
#     2           3
#    one   two   two
# a  0.0  15.0  20.0
# b  1.0  16.0  21.0
# c  2.0  17.0  22.0
# d  3.0  18.0  23.0
# e  4.0  19.0  24.0

'''
根据索引级别分组
'''
columns=pd.MultiIndex.from_arrays([['US',"US",'US','JP','JP'],[1,3,5,1,3]],names=['cty','tenor'])
hier_df=pd.DataFrame(np.random.randn(4,5),columns=columns)
print(hier_df)
# cty          US                            JP
# tenor         1         3         5         1         3
# 0     -1.507729  2.112678  0.841736 -0.158109 -0.645219
# 1      0.355262  0.765209 -0.287648  1.134998 -0.440188
# 2      1.049813  0.763482 -0.362013 -0.428725 -0.355601
# 3     -0.868420 -1.213398 -0.386798  0.137273  0.678293

#根据级别分组
print(hier_df.groupby(level='cty',axis=1).count())
# cty  JP  US
# 0     2   3
# 1     2   3
# 2     2   3
# 3     2   3

(6) 高级数据聚合

1 可以使用pd.merge()函数包聚合操作的计算结果添加到df的每一行

d1={'item':['luobo','baicai','lajiao','donggua','luobo','baicai','lajiao','donggua'],
   'color':['white','white','red','green','white','white','red','green'],
   'weight':np.random.randint(10,size = 8),
   'price':np.random.randint(10,size = 8)}
df = DataFrame(d1)
sums = df.groupby('color').sum().add_prefix('total_')

items = df.groupby('item')['price','weight'].sum()

means = items['price']/items['weight']

means = DataFrame(means,columns=['means_price'])

df2 = pd.merge(df,sums,left_on = 'color',right_index = True)

df3 = pd.merge(df2,means,left_on = 'item',right_index = True)
display(df2,df3)


#输出：
color   item    price   weight
0   white   luobo   9   2
1   white   baicai  5   9
2   red lajiao  5   8
3   green   donggua 1   1
4   white   luobo   7   4
5   white   baicai  8   0
6   red lajiao  6   8
7   green   donggua 4   3
total_price total_weight
color       
green   5   4
red 11  16
white   29  15
pandas.core.frame.DataFrame
pandas.core.frame.DataFrame
Out[141]:
        color   item    price   weight  total_price total_weight
0       white   luobo   9       2           29          15
1       white   baicai  5       9           29          15
4       white   luobo   7       4           29          15
5       white   baicai  8       0           29          15
2       red     lajiao  5       8           11          16
6       red     lajiao  6       8           11          16
3       green   donggua 1       1           5           4
7       green   donggua 4       3           5           4

2 可以使用transform和apply实现相同功能

使用transform

d1={'item':['luobo','baicai','lajiao','donggua','luobo','baicai','lajiao','donggua'],
   'color':['white','white','red','green','white','white','red','green'],
   'weight':np.random.randint(10,size = 8),
   'price':np.random.randint(10,size = 8)}
df = DataFrame(d1)
sum1 = df.groupby('color')['price','weight'].sum().add_prefix("total_")
sums2 = df.groupby('color')['price','weight'].transform(lambda x:x.sum()).add_prefix('total_')
sums3 = df.groupby('color')['price','weight'].transform(sum).add_prefix('total_')
display(sum,df,sum1,sums2,sums3)

输出：
<function sum>
color   item    price   weight
0   white   luobo   7   7
1   white   baicai  7   7
2   red lajiao  2   7
3   green   donggua 6   6
4   white   luobo   1   2
5   white   baicai  3   6
6   red lajiao  7   0
7   green   donggua 0   2
total_price total_weight
color       
green   6   8
red 9   7
white   18  22
total_price total_weight
0   18  22
1   18  22
2   9   7
3   6   8
4   18  22
5   18  22
6   9   7
7   6   8
total_price total_weight
0   18  22
1   18  22
2   9   7
3   6   8
4   18  22
5   18  22
6   9   7
7   6   8

使用apply

def sum_price(x):
    return x.sum()
sums3 = df.groupby('color')['price','weight'].apply(lambda x:x.sum()).add_prefix('total_')
sums4 = df.groupby('color')['price','weight'].apply(sum_price).add_prefix('total_')
display(df,sums3,sums4)

输出：
color   item    price   weight
0   white   luobo   4   4
1   white   baicai  0   3
2   red lajiao  0   4
3   green   donggua 7   5
4   white   luobo   3   1
5   white   baicai  3   3
6   red lajiao  0   6
7   green   donggua 0   7
total_price total_weight
color       
green   7   12
red 0   10
white   10  11
totals_price    totals_weight
color       
green   7   12
red 0   10
white   10  11
文章标签：
索引
Python
数据处理
数据挖掘
关键词：
Pandas数据处理
Pandas数据分析
数据分析数据处理
数据分析pandas
数据分析pandas数据处理
蓝色の流星VIP
目录
相关文章
凉凉心.
|
1月前
|
Java 数据处理 索引
（Pandas）Python做数据处理必选框架之一！（二）：附带案例分析；刨析DataFrame结构和其属性；学会访问具体元素；判断元素是否存在；元素求和、求标准值、方差、去重、删除、排序...
DataFrame结构 每一列都属于Series类型，不同列之间数据类型可以不一样，但同一列的值类型必须一致。 DataFrame拥有一个总的 idx记录列，该列记录了每一行的索引 在DataFrame中，若列之间的元素个数不匹配，且使用Series填充时，在DataFrame里空值会显示为NaN；当列之间元素个数不匹配，并且不使用Series填充，会报错。在指定了index 属性显示情况下，会按照index的位置进行排序，默认是 [0,1,2,3,...] 从0索引开始正序排序行。
凉凉心.
232 0
凉凉心.
|
1月前
|
Java 数据挖掘 数据处理
（Pandas）Python做数据处理必选框架之一！（一）：介绍Pandas中的两个数据结构；刨析Series：如何访问数据；数据去重、取众数、总和、标准差、方差、平均值等；判断缺失值、获取索引...
Pandas 是一个开源的数据分析和数据处理库，它是基于 Python 编程语言的。 Pandas 提供了易于使用的数据结构和数据分析工具，特别适用于处理结构化数据，如表格型数据（类似于Excel表格）。 Pandas 是数据科学和分析领域中常用的工具之一，它使得用户能够轻松地从各种数据源中导入数据，并对数据进行高效的操作和分析。 Pandas 主要引入了两种新的数据结构：Series 和 DataFrame。
凉凉心.
380 0
Deephub
|
4月前
|
自然语言处理 数据挖掘 数据处理
告别低效代码：用对这10个Pandas方法让数据分析效率翻倍
本文将介绍 10 个在数据处理中至关重要的 Pandas 技术模式。这些模式能够显著减少调试时间，提升代码的可维护性，并构建更加清晰的数据处理流水线。
Deephub
195 3
告别低效代码：用对这10个Pandas方法让数据分析效率翻倍
站大爷
|
3月前
|
存储 数据采集 数据处理
Pandas与NumPy：Python数据处理的双剑合璧
Pandas与NumPy是Python数据科学的核心工具。NumPy以高效的多维数组支持数值计算，适用于大规模矩阵运算；Pandas则提供灵活的DataFrame结构，擅长处理表格型数据与缺失值。二者在性能与功能上各具优势，协同构建现代数据分析的技术基石。
站大爷
352 0
Echo_Wish
|
6月前
|
分布式计算 Hadoop 数据挖掘
“Hadoop整不明白，数据分析就白搭？”——教你用Hadoop撸清大数据处理那点事
“Hadoop整不明白，数据分析就白搭？”——教你用Hadoop撸清大数据处理那点事
Echo_Wish
317 34
站大爷
|
5月前
|
运维 数据挖掘 数据处理
Pandas时间数据处理：从基础到进阶的实战指南
Pandas时间数据处理涵盖了从基础到高级的全面功能。其核心由Timestamp、DatetimeIndex、Period和Timedelta四个类构建，支持精准的时间点与区间操作。内容包括时间数据生成（字符串解析与序列生成）、时间索引与切片、高级运算（偏移重采样与窗口计算）、时区处理、周期性数据分析及实战案例（如智能电表数据）。此外，还涉及性能优化技巧和未来展望，帮助用户高效处理时间序列数据并应用于预测分析等场景。
站大爷
269 1
站大爷
|
5月前
|
传感器 安全 数据处理
Pandas时间数据处理：从基础到进阶的实战指南
本文深入讲解Pandas时间数据处理技巧，从时间对象转换到高性能计算全面覆盖。通过真实案例拆解，掌握Timestamp与Period的核心概念、时间序列生成、重采样方法及窗口函数应用。同时剖析时区处理、性能优化策略及常见陷阱解决方案，并展望Pandas 2.0的时间处理新特性。内容强调“时间索引优先”原则，助你高效分析股票K线、用户行为等时间序列数据。
站大爷
172 0
长梦
|
9月前
|
数据可视化 数据挖掘 数据处理
Pandas高级数据处理：交互式数据探索
Pandas 是数据分析中常用的数据处理库，提供了强大的数据结构和操作功能。本文从基础到高级，逐步介绍 Pandas 中交互式数据探索的常见问题及解决方案，涵盖数据读取、检查、清洗、预处理、聚合分组和可视化等内容。通过实例代码，帮助用户解决文件路径错误、编码问题、数据类型不一致、缺失值处理等挑战，提升数据分析效率。
长梦
223 32
长梦
|
9月前
|
数据采集 数据可视化 数据处理
Pandas高级数据处理：数据仪表板制作
《Pandas高级数据处理：数据仪表板制作》涵盖数据清洗、聚合、时间序列处理等技巧，解决常见错误如KeyError和内存溢出。通过多源数据整合、动态数据透视及可视化准备，结合性能优化与最佳实践，助你构建响应快速、数据精准的商业级数据仪表板。适合希望提升数据分析能力的开发者。
长梦
261 31
长梦
|
9月前
|
存储 安全 数据处理
Pandas高级数据处理：数据安全与隐私保护
在数据驱动的时代，数据安全和隐私保护至关重要。本文探讨了使用Pandas进行数据分析时如何确保数据的安全性和隐私性，涵盖法律法规要求、用户信任和商业价值等方面。通过加密、脱敏、访问控制和日志审计等技术手段，结合常见问题及解决方案，帮助读者在实际项目中有效保护数据。
长梦
319 29

热门文章

最新文章

  • 1
    如何构建企业级数据智能体：Data Agent 开发实践
  • 2
    基于python大数据技术的医疗数据分析与研究
  • 3
    构建企业级数据分析助手：Data Agent 开发实践
  • 4
    通义灵码产品演示： 数据库设计与数据分析
  • 5
    数据分析真能让音乐产业更好听吗？——聊聊大数据在音乐里的那些事
  • 6
    pandas读excel类型文件报错: xlrd.biffh.XLRDError: Excel xlsx file； not supported
  • 7
    pandas.to_numeric转化数据为数字型
  • 8
    pandas 前后行操作
  • 9
    Python机器学习数据建模与分析——Numpy和Pandas综合应用案例：空气质量监测数据的预处理和基本分析
  • 10
    pandas中报错：TypeError: reduction operation ‘argmax‘ not allowed for this dtype 的解决办法
  • 1
    实时数据分析：如何利用API优化营销决策
    258
  • 2
    电商数据分析师进阶指南：高效运用API的N种技巧！
    143
  • 3
    基于 StarRocks + Iceberg，TRM Labs 构建 PB 级数据分析平台实践
    259
  • 4
    “脏数据不清，分析徒劳”——聊聊数据分析里最容易被忽视的苦差事
    216
  • 5
    不懂 PromQL，AI 智能体帮你玩转大规模指标数据分析
    562
  • 6
    Python数据分析，别再死磕Excel了！
    295
  • 7
    “Hadoop整不明白，数据分析就白搭？”——教你用Hadoop撸清大数据处理那点事
    317
  • 8
    别再“拍脑袋”决策了，学点数据分析，从零起步也不晚！
    172
  • 9
    云上玩转Qwen3系列之三：PAI-LangStudio x Hologres构建ChatBI数据分析Agent应用
    521
  • 10
    飞桨x昇腾生态适配方案：07_性能数据分析
    258

    • 相关课程

    更多
  • 实时数据分析：使用Flink实时发现最热Github项目
  • 日志服务 SLS 可观测数据分析平台介绍
  • Quick BI在业务数据分析中的实战应用
  • Python 数据分析库 Pandas 快速入门
  • 深入理解数据分析
  • 场景实践-通过阿里云数据分析工具实现共享单车骑行分析

    • 相关电子书

    更多
  • 第十二届 BigData NoSQL Meetup — 快手HBase在千亿级用户特征数据分析中的应用与实践
  • 中文：即学即用的Pandas入门与时间序列分析
  • 即学即用的Pandas入门与时间序列分析

    • 相关实验场景

    更多
  • AnalyticDB Zero-ETL：简单易用零成本的一站式数据分析
    • 下一篇
    阿里云负载均衡收费标准：ALB、NLB和CLB价格，包括LCU费用、实例费和公网带宽价格