Pandas之DataFrame，快速入门，迅速掌握（二）

Pandas之DataFrame，快速入门，迅速掌握（一）https://developer.aliyun.com/article/1496714

三、Pandas数据结构Dataframe：基本技巧

数据查看、转置 / 添加、修改、删除值 / 对齐 / 排序

1.数据查看、转置

df = pd.DataFrame(np.random.rand(16).reshape(8,2)*100,
                   columns = ['a','b'])
print(df.head(2))
print(df.tail())
# .head()查看头部数据  默认前面5行
# .tail()查看尾部数据   后5行
# 默认查看5条

print(df.T)
# .T 转置  旋转90度

2.添加与修改

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df)

df['e'] = 10
df.loc[4] = 20
print(df)

新增列/行并赋值

df['e'] = 20
df[['a','c']] = 100
print(df)

索引后直接修改值

3.删除 del / drop()

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df)

del df['a']
print(df)
print('-----')

del语句 - 删除列

print(df.drop(0))
print(df.drop([1,2]))
print(df)
print('-----')

drop()删除行，inplace=False → 删除后生成新的数据，不改变原数据

print(df.drop(['d'], axis = 1))
print(df)

drop()删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据

指定index和columns

相比上面的方法，这种方法可以同时删除行和列，即直接指定index和columns（分别代表行、列，可以是单个索引名或索引名组成的列表）

df.drop(columns=[‘choose’], inplace=True) 删除列

4.dropna

dropna()是一个Pandas库中的函数，用于从数据框（DataFrame）中删除包含缺失值（NaN）的行或列。它用于数据清洗和预处理阶段，以便去除缺失值，使数据更加规整。

ropna()函数的语法如下：

DataFrame.dropna(axis=0, how=‘any’, thresh=None, subset=None, inplace=False)

参数说明：

axis：可选参数，表示删除行还是列。默认值为0，表示删除包含缺失值的行；设置为1表示删除包含缺失值的列。

how：可选参数，表示删除的条件。默认值为’any’，表示只要存在一个缺失值就删除整行或整列；设置为’all’表示只有当整行或整列都是缺失值时才删除。

thresh：可选参数，表示在删除之前需要满足的非缺失值的最小数量。如果行或列中的非缺失值数量小于等于thresh，则会被删除。

subset：可选参数，用于指定要检查缺失值的特定列名或行索引。

inplace：可选参数，表示是否对原始数据进行就地修改。默认值为False，表示不修改原始数据，而是返回一个新的数据框。下面是一些使用dropna()函数的示例：

import pandas as pd

# 创建包含缺失值的数据框
data = {'A': [1, 2, None, 4],
        'B': [None, 6, 7, 8],
        'C': [9, 10, 11, 12]}
df = pd.DataFrame(data)


# 删除包含缺失值的行
cleaned_df = df.dropna()

# 删除包含缺失值的列
cleaned_df = df.dropna(axis=1)

# 只删除整行或整列都是缺失值的行或列
cleaned_df = df.dropna(how='all')

# 至少需要2个非缺失值才保留行或列
cleaned_df = df.dropna(thresh=2)

# 只在特定列中检查缺失值
cleaned_df = df.dropna(subset=['A', 'C'])

# 在原始数据上进行就地修改
df.dropna(inplace=True)

5.对齐

df1 = pd.DataFrame(np.random.randn(10, 4), columns=[‘A’, ‘B’, ‘C’, ‘D’])

df2 = pd.DataFrame(np.random.randn(7, 3), columns=[‘A’, ‘B’, ‘C’])

print(df1 + df2)

DataFrame对象之间的数据自动按照列和索引（行标签）对齐 任何值与空值运算，结果都是空值

6.排序1 - 按值排序 .sort_values 这是按某一列的值进行排序

同样适用于Series

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df1)
print(df1.sort_values(['a'], ascending = True))  # 升序
print(df1.sort_values(['a'], ascending = False))  # 降序
print('------')

ascending参数：设置升序降序，默认升序

单列排序

df2 = pd.DataFrame({'a':[1,1,1,1,2,2,2,2],
                  'b':list(range(8)),
                  'c':list(range(8,0,-1))})
print(df2)
print(df2.sort_values(['a','c'])) 里面是列表

多列排序，按列顺序排序 从左往右排序，左边一样，再按右边制定顺序排序

7.排序2 - 索引排序 .sort_index 按行索引排序

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = [5,4,3,2],
                   columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = ['h','s','x','g'],
                   columns = ['a','b','c','d'])
print(df1)
print(df1.sort_index())
print(df2)
print(df2.sort_index())

按照index排序

默认 ascending=True, inplace=False

四、数值计算和统计基础

1.常用数学、统计方法

基本参数：axis、skipna

import numpy as np
import pandas as pd

df = pd.DataFrame({'key1':[4,5,3,np.nan,2],
                 'key2':[1,2,np.nan,4,5],
                 'key3':[1,2,3,'j','k']},
                 index = ['a','b','c','d','e'])
print(df)
print(df['key1'].dtype,df['key2'].dtype,df['key3'].dtype)
print('-----')

m1 = df.mean()
print(m1,type(m1))
print('单独统计一列:',df['key2'].mean())
print('-----')

np.nan ：空值

.mean()计算均值 新版的，字符串与数值计算会报错

只统计数字列

可以通过索引单独统计一列

新版的有字符串不能参与运算，不然报错

m2 = df.mean(axis=1)
print(m2)
print(‘-----’)
axis参数：默认为0，以列来计算，axis=1，以行来计算，这里就按照行来汇总了

m3 = df.mean(skipna=False)
print(m3)
print(‘-----’)
skipna参数：是否忽略NaN，默认True，如False，有NaN的列统计结果仍为NaN

2.主要数学计算方法，可用于Series和DataFrame（）

df = pd.DataFrame({'key1':np.arange(10),
                  'key2':np.random.rand(10)*10})
print(df)
print('-----')

print(df.count(),'→ count统计非Na值的数量\n')

print(df.min(),‘→ min统计最小值\n’,df[‘key2’].max(),‘→ max统计最大值\n’)

print(df.quantile(q=0.75),‘→ quantile统计分位数，参数q确定位置\n’)

print(df.sum(),‘→ sum求和\n’) 默认都是按列的，加上axis=1.就按行计算

按行计算

print(df.mean(),‘→ mean求平均值\n’)

print(df.median(),‘→ median求算数中位数，50%分位数\n’)

print(df.std(),‘\n’,df.var(),‘→ std,var分别求标准差，方差\n’)

print(df.skew(),‘→ skew样本的偏度\n’)

print(df.kurt(),‘→ kurt样本的峰度\n’)

主要数学计算方法，可用于Series和DataFrame（2）

df[‘key1_s’] = df[‘key1’].cumsum()
df[‘key2_s’] = df[‘key2’].cumsum()
print(df,‘→ cumsum样本的累计和\n’)

df[‘key1_p’] = df[‘key1’].cumprod()
df[‘key2_p’] = df[‘key2’].cumprod()
print(df,‘→ cumprod样本的累计积\n’)

print(df.cummax(),‘\n’,df.cummin(),‘→ cummax,cummin分别求累计最大值，累计最小值\n’)

会填充key1，和key2的值

唯一值：.unique()

s = pd.Series(list(‘asdvasdcfgg’))
sq = s.unique()
print(s)
print(sq,type(sq))
print(pd.Series(sq))

得到一个唯一值数组

通过pd.Series重新变成新的Series

sq.sort()

print(sq)

重新排序

值计数：.value_counts()

sc = s.value_counts(sort = False) # 也可以这样写：pd.value_counts(sc, sort = False)

print(sc)

得到一个新的Series，计算出不同值出现的频率

sort参数：排序，默认为True

成员资格：.isin()

s = pd.Series(np.arange(10,15))
df = pd.DataFrame({‘key1’:list(‘asdcbvasd’),
‘key2’:np.arange(4,13)})
print(s)
print(df)
print(‘-----’)

print(s.isin([5,14])) 就算只有一个元素也要加中括号
print(df.isin([‘a’,‘bc’,‘10’,8]))

用[]表示

得到一个布尔值的Series或者Dataframe

3.文本数据

Pandas针对字符串配备的一套方法，使其易于对数组的每个元素进行操作

（1）通过str访问，且自动排除丢失/ NA值

s = pd.Series([‘A’,‘b’,‘C’,‘bbhello’,‘123’,np.nan,‘hj’])
df = pd.DataFrame({‘key1’:list(‘abcdef’),
‘key2’:[‘hee’,‘fv’,‘w’,‘hija’,‘123’,np.nan]})
print(s)
print(df)
print(‘-----’)

print(s.str.count(‘b’)) #计算出现的次数
print(df[‘key2’].str.upper())
print(‘-----’)

直接通过.str调用字符串方法

可以对Series、Dataframe使用 首先里面的数据得是字符串类型，不然报错

自动过滤NaN值

df.columns = df.columns.str.upper()

print(df)

df.columns是一个Index对象，也可使用.str

（2）字符串常用方法 - lower，upper，len，startswith，endswith Series可以直接用，Dataframe要指定行或列才能用

s = pd.Series([‘A’,‘b’,‘bbhello’,‘123’,np.nan])

print(s.str.lower(),‘→ lower小写\n’)
print(s.str.upper(),‘→ upper大写\n’)
print(s.str.len(),‘→ len字符长度\n’)
print(s.str.startswith(‘b’),‘→ 判断起始是否为a\n’)
print(s.str.endswith(‘3’),‘→ 判断结束是否为3\n’)

字符串常用方法（2） - strip

s = pd.Series([’ jack’, 'jill ', ’ jesse ‘, ‘frank’])
df = pd.DataFrame(np.random.randn(3, 2), columns=[’ Column A ‘, ’ Column B ‘],
index=range(3))
print(s)
print(df)
print(’-----’)

print(s.str.strip()) # 去除字符串两边的空格
print(s.str.lstrip()) # 去除字符串的左空格
print(s.str.rstrip()) # 去除字符串的右空格

df.columns = df.columns.str.strip()
print(df)

这里去掉了columns的前后空格，但没有去掉中间空格

字符串常用方法（3） - replace

df = pd.DataFrame(np.random.randn(3, 2), columns=[’ Column A ‘, ’ Column B ‘],
index=range(3))
df.columns = df.columns.str.replace(’ ‘,’-’)
print(df)

替换

df.columns = df.columns.str.replace(‘-’,‘hehe’,n=1)

print(df)

n：替换个数

字符串常用方法（3） - replace

df = pd.DataFrame(np.random.randn(3, 2), columns=[’ Column A ‘, ’ Column B ‘],
index=range(3))
print(df)
print(“替换后”)
df.columns = df.columns.str.replace(’ ‘,’-’)
print(df,type(df))
替换
#将之转换为字符串，才有str方法
df =df.astype(str) #astype返回新Dataframe，原数据不变，所以要重新赋值
#替换列
print(“---------------”)
print(df[‘-Column-B-’].str.replace(“.”,“D”))
print(df[‘-Column-B-’])

并且不能直接对Dataframe操作，要指定行或列。否则报错

字符串常用方法（4） - split、rsplit

s = pd.Series([‘a,b,c’,‘1,2,3’,[‘a,c’],np.nan])
print(s.str.split(‘,’))
print(‘-----’)

类似字符串的split

列表不会切割

print(s.str.split(‘,’)[0])

print(‘-----’)

直接索引得到一个list

print(s.str.split(‘,’).str[0])
print(s.str.split(‘,’).str.get(1))
print(‘-----’)

可以使用get或[]符号访问拆分列表中的元素

print(s.str.split(‘,’, expand=True)) #默认是False
print(s.str.split(‘,’, expand=True, n = 1))
print(s.str.rsplit(‘,’, expand=True, n = 1))
print(‘-----’)

可以使用expand可以轻松扩展此操作以返回DataFrame

n参数限制分割数

rsplit类似于split，反向工作，即从字符串的末尾到字符串的开头

df = pd.DataFrame({‘key1’:[‘a,b,c’,‘1,2,3’,[‘:,., ‘]],
‘key2’:[‘a-b-c’,‘1-2-3’,[’:-.- ‘]]})
print(df[‘key2’].str.split(’-’))
Dataframe使用split

字符串索引

s = pd.Series([‘A’,‘b’,‘C’,‘bbhello’,‘123’,np.nan,‘hj’])
df = pd.DataFrame({‘key1’:list(‘abcdef’),
‘key2’:[‘hee’,‘fv’,‘w’,‘hija’,‘123’,np.nan]})
print(s.str[0]) # 取第一个字符串
print(s.str[:2]) # 取前两个字符串

print(df[‘key2’].str[0])

str之后和字符串本身索引方式相同

Pandas之DataFrame，快速入门，迅速掌握（三）https://developer.aliyun.com/article/1496718