Python13--数据分析Pandas库进阶二

最新推荐文章于 2024-06-11 20:38:14 发布
最新推荐文章于 2024-06-11 20:38:14 发布
阅读量396 收藏
点赞数 1
分类专栏： Python 数据分析 文章标签： python 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42011858/article/details/115048636
版权

一、层级索引

下面创建一个Series， 在输入索引Index时，输入了由两个子list组成的list，第一个子list是外层索引，第二个list是内层索引。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(ser_obj)

显示结果：
层级索引

1，MultiIndex索引对象

打印这个Series的索引类型，显示是MultiIndex
直接将索引打印出来，可以看到有lavels,和labels两个信息。lavels表示两个层级中分别有那些标签，labels是每个位置分别是什么标签。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(type(ser_obj.index))
print(ser_obj.index)

显示结果：
MultiIndex索引对象

2，选取子集

根据索引获取数据。因为现在有两层索引，当通过外层索引获取数据的时候，可以直接利用外层索引的标签来获取。
当要通过内层索引获取数据的时候，在list中传入两个元素，前者是表示要选取的外层索引，后者表示要选取的内层索引。

（1）外层选取

语法格式：ser_obj['outer_label']

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 外层选取
print(ser_obj['c'])

显示结果：
外层选取

（2）内层选取

语法格式：ser_obj[:, 'inner_label']

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 内层选取
print(ser_obj[:, 2])

显示结果：
内层选取

3，交换分层顺序

swaplevel()：.swaplevel( )交换内层与外层索引。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(ser_obj.swaplevel())

显示结果：
交换分层顺序

4，交换并排序分层

sortlevel()：.sortlevel( )先对外层索引进行排序，再对内层索引进行排序，默认是升序。
但是pandas的包中在0.23.4版本中就取消了sort方法，老版本的Series和DataFrame对象中还包含这个函数，新版本中推荐使用sort_index和sort_values函数。
所以应该首先查看自己的版本，然后选取对应的函数对索引进行排序。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 交换并排序分层
print(ser_obj.swaplevel().sort_index())

显示结果：
交换并排序分层

二、统计计算和描述

1，常用的统计计算

sum, mean, max, min…
axis=0 按列统计，axis=1按行统计
skipna 排除缺失值， 默认为True

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj)

print(df_obj.sum())
print(df_obj.max())
print(df_obj.min(axis=1, skipna=False))

显示结果：
常用的统计计算

2，常用的统计描述

describe 产生多个统计数据

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj)

print(df_obj.describe())

显示结果：
常用的统计描述

3，常用的统计描述方法

方法说明
count非NA值的数量
describe针对DataFrame与Series计算汇总统计
min、max计算最大值与最小值
argmin、argmax计算能够获取到的最大值与最小值的索引位置
idxmin、idmax计算能够获取到的最大值与最小值的索引值
quantile计算样本的分位数
sum值的总和
mean值的平均值
median值的算术中位数
mad根据平均值计算平均绝对离差
var样本值的方差
std样本值的标准差
skew样本值的偏度
kurt样本值的峰度
cumsum样本值的累计和
cummin、cummax样本值的累计最大值与累计最小值
cumprod样本值的累计积
diff计算一阶差分（一般使用在时间序列中）
pct_change计算百分比的变化

三、分组

定义：对数据集进行分组，然后对每组进行统计分析；SQL能够对数据进行过滤，分组聚合；pandas能利用groupby进行更加复杂的分组运算。
分组运算过程：split->apply->combine
	拆分：进行分组的根据
	应用：每个分组运行的计算规则
	合并：把每个分组的计算结果合并起来

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)
print(df_obj)

显示结果：
分组

1，GroupBy对象：DataFrameGroupBy，SeriesGroupBy

（1）分组操作

groupby()进行分组，GroupBy对象没有进行实际运算，只是包含分组的中间数据。
按列名分组代码格式：obj.groupby(‘label’)

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# dataframe根据key1进行分组
print(type(df_obj.groupby('key1')))

# dataframe的 data1 列根据 key1 进行分组
print(type(df_obj['data1'].groupby(df_obj['key1'])))

显示结果：
分组操作

（2）分组运算

对GroupBy对象进行分组运算/多重分组运算，如mean()
非数值数据不进行分组运算
size() 返回每个分组的元素个数

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 分组运算
grouped1 = df_obj.groupby('key1')
print(grouped1.mean())

grouped2 = df_obj['data1'].groupby(df_obj['key1'])
print(grouped2.mean())

print(grouped1.size())
print(grouped2.size())

显示结果：
分组运算

（3）按自定义的key分组

语法格式：obj.groupby(self_def_key)
自定义的key可为列表或多层列表
obj.groupby([‘label1’, ‘label2’])->多层dataframe

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

# 按自定义key分组，多层列表
print(df_obj.groupby([df_obj['key1'], df_obj['key2']]).size())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
print(grouped2.size())

# 多层分组按key的顺序进行
grouped3 = df_obj.groupby(['key2', 'key1'])
print(grouped3.mean())
# unstack可以将多层索引的结果转换成单层的dataframe
print(grouped3.mean().unstack())

显示结果：
按自定义的key分组

2，GroupBy对象支持迭代操作

每次迭代返回一个元组 (group_name, group_data)
可用于分组数据的具体运算

（1）单层分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

grouped2 = df_obj['data1'].groupby(df_obj['key1'])
# print(grouped2.mean())
# 单层分组，根据key1
for group_name, group_data in grouped1:
    print(group_name)
    print(group_data)

显示结果：
单层分组

（2）多层分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 多层分组，根据key1 和 key2
for group_name, group_data in grouped2:
    print(group_name)
    print(group_data)

显示结果：
多层分组

3，GroupBy对象可以转换成列表或字典

（1）GroupBy对象可以转换成列表或字典

（2）按列分组、按数据类型分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 按列分组
print(df_obj.dtypes)

# 按数据类型分组
print(df_obj.groupby(df_obj.dtypes, axis=1).size())
print(df_obj.groupby(df_obj.dtypes, axis=1).sum())

显示结果：
按列分组、按数据类型分组

（3）通过字典分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

df_obj2 = pd.DataFrame(np.random.randint(1, 10, (5,5)),
                       columns=['a', 'b', 'c', 'd', 'e'],
                       index=['A', 'B', 'C', 'D', 'E'])
# 通过字典分组
mapping_dict = {'a':'Python', 'b':'Python', 'c':'Java', 'd':'C', 'e':'Java'}
print(df_obj2.groupby(mapping_dict, axis=1).size())
print(df_obj2.groupby(mapping_dict, axis=1).count()) # 非NaN的个数
print(df_obj2.groupby(mapping_dict, axis=1).sum())

显示结果：
通过字典分组

（4）通过函数分组，函数传入的参数为行索引或列索引

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 通过函数分组
df_obj3 = pd.DataFrame(np.random.randint(1, 10, (5,5)),
                       columns=['a', 'b', 'c', 'd', 'e'],
                       index=['AA', 'BBB', 'CC', 'D', 'EE'])
#df_obj3

def group_key(idx):
    """
        idx 为列索引或行索引
    """
    #return idx
    return len(idx)

print(df_obj3.groupby(group_key).size())

# 以上自定义函数等价于
#df_obj3.groupby(len).size()

显示结果：
通过函数分组，函数传入的参数为行索引或列索引

（5）通过索引级别分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

# 通过索引级别分组
columns = pd.MultiIndex.from_arrays([['Python', 'Java', 'Python', 'Java', 'Python'],
                                     ['A', 'A', 'B', 'C', 'B']], names=['language', 'index'])
df_obj4 = pd.DataFrame(np.random.randint(1, 10, (5, 5)), columns=columns)
print(df_obj4)

# 根据language进行分组
print(df_obj4.groupby(level='language', axis=1).sum())
# 根据index进行分组
print(df_obj4.groupby(level='index', axis=1).sum())

显示结果：
通过索引级别分组

四，聚合

数组产生标量的过程，如mean()、count()等
常用于对分组后的数据进行计算

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj5 = pd.DataFrame(dict_obj)
print(df_obj5)

显示结果：
聚合示例

1，内置的聚合函数

sum(), mean(), max(), min(), count(), size(), describe()

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj5 = pd.DataFrame(dict_obj)

print(df_obj5.groupby('key1').sum())
print(df_obj5.groupby('key1').max())
print(df_obj5.groupby('key1').min())
print(df_obj5.groupby('key1').mean())
print(df_obj5.groupby('key1').size())
print(df_obj5.groupby('key1').count())
print(df_obj5.groupby('key1').describe())

显示结果：
内置的聚合函数

2，可自定义函数，传入agg方法中

grouped.agg(func)
func的参数为groupby索引对应的记录

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 自定义聚合函数
def peak_range(df):
    """
        返回数值范围
    """
    #print type(df) #参数为索引所对应的记录
    return df.max() - df.min()

print(df_obj5.groupby('key1').agg(peak_range))
print(df_obj.groupby('key1').agg(lambda df : df.max() - df.min()))

显示结果：
自定义函数

3，应用多个聚合函数

同时应用多个函数进行聚合操作，使用函数列表

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 自定义聚合函数
def peak_range(df):
    """
        返回数值范围
    """
    #print type(df) #参数为索引所对应的记录
    return df.max() - df.min()

# 应用多个聚合函数

# 同时应用多个聚合函数
print(df_obj.groupby('key1').agg(['mean', 'std', 'count', peak_range])) # 默认列名为函数名

print(df_obj.groupby('key1').agg(['mean', 'std', 'count', ('range', peak_range)])) # 通过元组提供新的列名

显示结果：
应用多个聚合函数

4，对不同的列分别作用不同的聚合函数，使用dict

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 每列作用不同的聚合函数
dict_mapping = {'data1':'mean',
                'data2':'sum'}
print(df_obj.groupby('key1').agg(dict_mapping))

dict_mapping = {'data1':['mean','max'],
                'data2':'sum'}
print(df_obj.groupby('key1').agg(dict_mapping))

显示结果：
不同的列分别作用不同的聚合函数

5，常用的内置聚合函数

函数名说明
count分组中非NA的数量
sum非NA的和
mean非NA值的平均值
median非NA值的算数中位数
std、var标准差和方差
min、max非NA值的最大值和最小值
prod非NA值的积
first、last第一个或者最后一个非NA值

五、数据的分组运算

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
print(df_obj)

# 按key1分组后，计算data1，data2的统计信息并附加到原始表格中，并添加表头前缀
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
print(k1_sum)

显示结果：
数据的分组运算

1，merge

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
#print(df_obj)
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
# 方法1，使用merge
k1_sum_merge = pd.merge(df_obj, k1_sum, left_on='key1', right_index=True)
print(k1_sum_merge)

显示结果：
merge

2，transform

transform的计算结果和原始数据的形状保持一致，

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
#print(df_obj)
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
# 方法2，使用transform
k1_sum_tf = df_obj.groupby('key1').transform(np.sum).add_prefix('sum_')
df_obj[k1_sum_tf.columns] = k1_sum_tf
print(df_obj)

显示结果：
transform

六、聚类模型：K-Means

1，K-Means算法

算法接收参数k；然后将样本点划分为k个聚类；同一聚类中的样本相似度较高；不同聚类中的样本相似度较小

2，算法思想

以空间中k个样本点为中心进行聚类，对最靠近它们的样本点归类。通过迭 代的方法，逐步更新各聚类中心，直至达到最好的聚类效果

3，算法描述

（1）选择k个聚类的初始中心
（2）在第n次迭代中，对任意一个样本点，求其到k个聚类中心的距离，将该 样本点归类到距离最小的中心所在的聚类
（3）利用均值等方法更新各类的中心值
（4）对所有的k个聚类中心，如果利用2,3步的迭代更新后，达到稳定，则迭代 结束。

4，优缺点

优点：速度快，简单
缺点：最终结果和初始点的选择相关，容易陷入局部最优，需要给定k值
晓之以理的喵~~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数据框、序列定义及数据处理应用在线实验闯关
Junds0的博客
04-14 1266
本关任务：现有列表L1=[1,-2,2.3,‘hq’]、L2=[‘kl’,’ht’,’as’,’km’]和元组T1=(1,8,8,9)和T2=(2,4,7,’hp’)，请给出值为L1，采用默认索引和指定索引（a,b,c,d）两种方式的序列定义方法，以及索引为a,b,c,d，列名和值分别为L1、L2、T1、T2及其值的数据框构造方法。定义两个列表，两个元组，采用默认索引和指定索引(a,b,c,d)定义序列方法，以及索引为a,b,c,d，列名和值分别为L1、L2、T1、T2及其值的数据框构造方法。
Python数据处理库pandas进阶教程
hil2000的专栏
11-24 787
在前面一篇文章中，我们对pandas做了一些入门介绍。本文是它的进阶篇。在这篇文章中，我们会讲解一些更深入的知识。 前言 本文紧接着前一篇的入门教程，会介绍一些关于pandas的进阶知识。建议读者在阅读本文之前先看完pandas入门教程。 同样的，本文的测试数据和源码可以在这里获取： Github：pandas_tutorial 。 数据访问 在入门教程中，我们已经使用过访问数据的方法。...
【Python数据分析 - 13】：pandas的统计分析
Oh_Python的博客
09-24 582
在使用idxmin和idxmax时，axis=0表示列，axis=1表示行 isin函数用于查看某列中是否包含某个字符串，返回值为布尔Series，来表明每一行的情况。
【Pandas】深入解析pandas中的统计汇总函数`max()`
最新发布
qq_38614074的博客
06-11 385
Pandas的max()函数是一个功能强大的工具，可以帮助我们快速找出数据中的最大值。通过灵活设置参数和与其他函数结合使用，我们可以实现更复杂的数据分析任务。函数是一个用于计算DataFrame或Series对象中最大值的统计汇总函数。在数据分析和处理中，Pandas库是一个强大的工具，它提供了许多用于数据处理和分析的函数。在实际的数据分析中，我们通常会结合多个函数来进行多步骤的分析。函数是一个非常重要的统计汇总函数，用于计算数据中的最大值。函数默认会跳过NaN值（即缺失值），只计算非NaN值的最大值。
2020-11-22数据科学包学习第四天笔记Pandas
weixin_50934132的博客
11-22 189
文章目录Pandas1.创建一维数组，可以用列表或字典2.Series的索引和值3.读取外部数据2. DataFrame1.创建DataFrame数组2.DataFrame 索引1.行列索引2.布尔索引3.缺失数据处理 Pandas 1.创建一维数组，可以用列表或字典 pdP2.py import pandas as pd import string #用列表创建数组 t = pd.Series([1,2,31,12,3,4],index=list("abcdef")) print(t) #用字典创建数组
数据框、序列定义及数据处理应用
JS74110的博客
12-04 2112
'A2_进站人数':D1['A3_进站人数'].values,'A3_出站人数':D1['A4_出站人数'].values})sat_num=pd.DataFrame({'A1_站点编号':A1,'A2_日期':A2,'A3_进站人数':B['进站人数'].values,D1=D.groupby(['A1_站点编号'])[['A3_进站人数','A4_出站人数']].sum()B = A.groupby(['站点编号', '日期'])[['进站人数', '出站人数']].sum()
Python进阶-Pandas数据分析库
06-11
Pandas是python中非常常用的数据分析库，在数据分析，机器学习，深度学习等领域经常被使用。本课程会讲解到pandas中最核心的一些知识点，包括Series以及DataFrame的构建，赋值，操作，选择数据，合并等等，以及使用...
1天搞定Python进阶课程-数据分析库Pandas
06-09
pandas是python中非常常用的数据分析库，在数据分析，机器学习，深度学习等领域经常被使用。本课程会讲解到pandas中核心的一些知识点，包括Series以及DataFrame的构建，赋值，操作，选择数据，合并等等，以及使用...
Python数据分析神器——pandas（进阶教程）
12-21
**Python数据分析神器——pandas（进阶教程）** 在Python数据分析领域，pandas库是不可或缺的工具，尤其在处理和操作数据集时表现卓越。本文将深入探讨pandas的一些高级特性，包括数据合并、索引合并、轴向连接、...
Python数据科学速查表 - Pandas 进阶1
08-04
【Python数据科学速查表 - Pandas 进阶1】主要涵盖了Pandas库在数据处理中的高级操作，包括数据重塑、索引管理、缺失值处理、数据选择与过滤以及数据合并等多个方面。以下是对这些知识点的详细说明： 1. **数据重塑...
python进阶-pandas资料.rar
02-15
通过深入学习这些知识，你将能够熟练地运用Pandas进行数据处理、分析和可视化，为你的Python数据分析工作打下坚实的基础。这份资料集将帮助你从基本概念到实践应用，逐步掌握Pandas的精髓。记得通过实践来巩固理论...
在pandas多重索引multiIndex中选定指定索引的行方法
09-19
今天小编就为大家分享一篇在pandas多重索引multiIndex中选定指定索引的行方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Pandas将列表（List）转换为数据框（Dataframe）
热门推荐
nageaixiaodenanhai的博客
04-05 5万+
转载：https://blog.csdn.net/claroja/article/details/64439735Python中将列表转换成为数据框有两种情况：第一种是两个不同列表转换成一个数据框，第二种是一个包含不同子列表的列表转换成为数据框。第一种：两个不同列表转换成为数据框from pandas.core.frame import DataFrame a=[1,2,3,4] #列表a b...
pandas库以及列表等相关语法
Spuer_Tiger
07-27 245
-Python_day03- （1）pandas读取文件基本操作： pd.read_csv(“文件路径”，engine=“python”)。 type()和dtypes，分别表示文件的格式dataframe和文件数据类型的格式。 (*)head()可打印前五行数据，tail()采用打印最后几行，format()采用格式化输出。 （2）columns和loc[]分别对列和行的索引及取值操作： co...
【Pandas库】(3) DataFrame的创建方法及基本操作
博观而约取，厚积而薄发
11-13 9223
各位同学好，今天给大家介绍一下Pandas库中DataFrame类型数据的创建方法和基本操作。 文章内容如下：（1）使用字典类创建。 字典类有：①数组、列表、元组构成的字典；②Series构造的字典；③字典构造的字典。（2）使用列表类创建。 列表类有：①二维数组；②字典构造的列表；③Series构成的列表（3）基本操作。 ①查看索引；②指定索引；③转置操作；④通过索引获取数据；⑤追加一列；⑥删除列 首先，我简单介绍一下DataFrame： ①...
Python之Pandas库学习（一）：简介
weixin_30354675的博客
06-23 170
官方文档 1. 安装Pandas windos下cmd：pip install pandas 导入pandas包：import pandas as pd 2. Series对象 带索引的一维数组 创建： s = pd.Series([12,-4,7,9]) print (s) 0 12 1 -4 2 7 3 9 dtype: int64 s = pd.Series(...
Pandas 11-综合练习
qq_34903176的博客
01-01 2506
Pandas 11-综合练习 import pandas as pd import numpy as np np.seterr(all = 'ignore') {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} 【任务一】企业收入的多样性 【题目描述】一个企业的产业收入多样性可以仿照信息熵的概念来定义收入熵指标 : I=−∑ip(xi)log(p(xi))I=-\sum_i{p(x_i)log(p
pandas操作excel 笔记
jacke121的专栏
10-08 5166
pandas操作excel 笔记
Python Pandas进阶：高效数据分析与实践
《有效Pandas》是一本深入介绍Python编程语言中的Pandas库的高级教程，对于数据科学专业人士来说，它是不可或缺的学习资料。这本书由Tom Augspurger编写，旨在帮助读者掌握Pandas的核心功能和高效实践，特别关注数据...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晓之以理的喵~~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值