系统重温Pandas笔记：（二）Pandas基础

最新推荐文章于 2024-08-01 19:41:06 发布
最新推荐文章于 2024-08-01 19:41:06 发布
阅读量606 收藏 2
点赞数
分类专栏： Pandas 文章标签： python pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44934584/article/details/111315205
版权

文章目录

写在前面

本文内容源自Datawhale 组队学习教程，并结合了部分自己的笔记和感悟。对Datawhale感兴趣且想进一步了解：https://github.com/datawhalechina/joyful-pandas

一、文件的读取和写入

1. 文件读取

读取csv, excel, txt：

df_csv = pd.read_csv('data/my_csv.csv')

df_txt = pd.read_table('data/my_table.txt')

df_excel = pd.read_excel('data/my_excel.xls')

三个函数里常用的公共参数:

  • header=None表示第一行不作为列名

  • index_col表示把某一列或几列作为索引（第三章）

  • usecols表示读取列的集合，默认读取所有的列

  • parse_dates表示需要转化为时间的列（第十章） 2020/1/1变为2020-01-01

  • nrows表示读取的数据行数

在读取txt文件时，经常遇到分隔符非空格的情况，read_table有一个分割参数sep，它使得用户可以自定义分割符号，进行txt数据的读取。

  • sep : 字符串，分割符，默认值为‘，’。长度大于1个字符的分隔符将被解释为正则表达式,并强制使用Python解析引擎。正则表达式示例：’\r\t’
  • delimiter : 字符串,分割符，默认值为 none。其是相当于sep的替代品，指定delimiter，那么sep便失效。

例如，下面的读取的表以||||为分割：

pd.read_table('data/my_table_special_sep.txt')

	col1 |||| col2
0	TS |||| This is an apple.
1	GQ |||| My name is Bob.
2	WT |||| Well done!
3	PT |||| May I help you?

使用sep，同时需要指定引擎为python,需要对|进行转义变成\|（第八章）：

pd.read_table('data/my_table_special_sep.txt', sep=' \|\|\|\| ', engine='python')

	col1	col2
0	TS	This is an apple.
1	GQ	My name is Bob.
2	WT	Well done!
3	PT	May I help you?

2. 数据写入

一般在数据写入中，最常用的操作是把index设置为False，特别当索引没有特殊意义的时候，这样的行为能把索引在保存的时候去除。

df_csv.to_csv('data/my_csv_saved.csv', index=False)
df_excel.to_excel('data/my_excel_saved.xls', index=False)

pandas中没有定义to_table函数，但是to_csv可以保存为txt文件，并且允许自定义分隔符，常用制表符\t分割：

df_txt.to_csv('data/my_txt_saved.txt', sep='\t', index=False)

如果想要把表格快速转换为markdown和latex语言，可以使用to_markdown和to_latex函数。

  • markdown`：
print(df_csv.to_markdown())

|    |   col1 | col2   |   col3 | col4   | col5     |
|---:|-------:|:-------|-------:|:-------|:---------|
|  0 |      2 | a      |    1.4 | apple  | 2020/1/1 |
|  1 |      3 | b      |    3.4 | banana | 2020/1/2 |
|  2 |      6 | c      |    2.5 | orange | 2020/1/5 |
|  3 |      5 | d      |    3.2 | lemon  | 2020/1/7 |

复制到markdown编辑器里：

col1col2col3col4col5
02a1.4apple2020/1/1
13b3.4banana2020/1/2
26c2.5orange2020/1/5
35d3.2lemon2020/1/7
  • latex
print(df_csv.to_latex())

\begin{tabular}{lrlrll}
\toprule
{} &  col1 & col2 &  col3 &    col4 &      col5 \\
\midrule
0 &     2 &    a &   1.4 &   apple &  2020/1/1 \\
1 &     3 &    b &   3.4 &  banana &  2020/1/2 \\
2 &     6 &    c &   2.5 &  orange &  2020/1/5 \\
3 &     5 &    d &   3.2 &   lemon &  2020/1/7 \\
\bottomrule
\end{tabular}

二、基本数据结构

pandas中具有两种基本的数据存储结构，存储一维values的Series和存储二维values的DataFrame，在这两种结构上定义了很多的属性和方法。

1. Series

Series一般由四个部分组成：

  • 序列的值data
  • 索引index（可以指定它的名字，默认为空）
  • 存储类型dtype
  • 序列的名字name
s = pd.Series(data = [100, 'a', {'dic1':5}],
              index = pd.Index(['id1', 20, 'third'], name='my_idx'),
              dtype = 'object',
              name = 'my_name')
s

my_idx
id1              100
20                 a
third    {'dic1': 5}
Name: my_name, dtype: object

object代表了一种混合类型，正如上面的例子中存储了整数、字符串以及Python的字典数据结构。此外，目前pandas把纯字符串序列也默认认为是一种object类型的序列，但它也可以用string类型存储（第八章）。

这些属性可以通过 . 的方式来获取：

s.values

array([100, 'a', {'dic1': 5}], dtype=object)

s.index #通过[index_item]可以取出单个索引对应的值

Index(['id1', 20, 'third'], dtype='object', name='my_idx')

s.dtype

dtype('O')

s.name

'my_name'

利用.shape可以获取序列的长度：

s.shape

(3,)

2. DataFrame

DataFrame在Series的基础上增加了列索引，一个数据框由二维的data与行列索引来构造：

data = [[1, 'a', 1.2], [2, 'b', 2.2], [3, 'c', 3.2]]
df = pd.DataFrame(data = data,
                  index = ['row_%d'%i for i in range(3)],
                  columns=['col_0', 'col_1', 'col_2'])
df

在这里插入图片描述
更多的时候会采用从列索引名到数据的映射来构造数据框，同时再加上行索引：

df = pd.DataFrame(data = {'col_0': [1,2,3],
                          'col_1':list('abc'),
                          'col_2': [1.2, 2.2, 3.2]},
                  index = ['row_%d'%i for i in range(3)])
df

在这里插入图片描述
由于这种映射关系，在DataFrame中可以用[col_name]与[col_list]来取出相应的列与由多个列组成的表，结果分别为Series和DataFrame：

  • Series：
df['col_0']

row_0    1
row_1    2
row_2    3
Name: col_0, dtype: int64
  • DataFrame：
df[['col_0', 'col_1']]

在这里插入图片描述
与Series类似，在数据框中同样可以取出相应的属性：

df.values
array([[1, 'a', 1.2],
       [2, 'b', 2.2],
       [3, 'c', 3.2]], dtype=object)
       
df.index
Index(['row_0', 'row_1', 'row_2'], dtype='object')

df.columns
Index(['col_0', 'col_1', 'col_2'], dtype='object')

df.dtypes # 返回的是值为相应列数据类型的Series
col_0      int64
col_1     object
col_2    float64
dtype: object

df.shape
(3, 3)

通过.T可以把DataFrame进行转置：

df.T

在这里插入图片描述

三、常用基本函数

为了进行举例说明，在接下来的部分和其余章节都将会使用一份learn_pandas.csv的虚拟数据集，它记录了四所学校学生的体测个人信息。

df = pd.read_csv('data/learn_pandas.csv')
df.columns

Index(['School', 'Grade', 'Name', 'Gender', 'Height', 'Weight', 'Transfer',
       'Test_Number', 'Test_Date', 'Time_Record'],
      dtype='object')

上述列名依次代表学校、年级、姓名、性别、身高、体重、是否为转系生、体测场次、测试时间、1000米成绩。
本章只需使用其中的前七列：

df = df[df.columns[:7]]

1. 汇总函数

head, tail函数分别表示返回表或者序列的前n行和后n行，其中n默认为5：

df.head(2)

在这里插入图片描述

df.tail(3)

在这里插入图片描述

  • info返回表的信息概况 ：
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 7 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   School    200 non-null    object 
 1   Grade     200 non-null    object 
 2   Name      200 non-null    object 
 3   Gender    200 non-null    object 
 4   Height    183 non-null    float64
 5   Weight    189 non-null    float64
 6   Transfer  188 non-null    object 
dtypes: float64(2), object(5)
memory usage: 11.1+ KB
  • describe返回表中数值列对应的主要统计量 ：
df.describe()

在这里插入图片描述
info, describe只能实现较少信息的展示，如果想要对一份数据集进行全面且有效的观察，特别是在列较多的情况下，推荐使用pandas-profiling包（第十一章）。

2. 特征统计函数

在Series和DataFrame上定义了许多统计函数，最常见的是sum, mean, median, var, std, max, min。例如，选出身高和体重列进行演示：

df_demo = df[['Height', 'Weight']]
df_demo.mean()
Height    163.218033
Weight     55.015873
dtype: float64

df_demo.max()
Height    193.9
Weight     89.0
dtype: float64

quantile, count, idxmax：分别返回的是分位数、非缺失值个数、最大值对应的索引：

  • quantile：
df_demo.quantile(0.75)

Height    167.5
Weight     65.0
Name: 0.75, dtype: float64
  • count：
df_demo.count()
Height    183
Weight    189
dtype: int64
  • idxmax：
df_demo.idxmax() # idxmin是对应的函数

Height    193
Weight      2
dtype: int64

上面这些所有的函数，由于操作后返回的是标量，所以又称为聚合函数，它们有一个公共参数axis，默认为0代表逐列聚合，如果设置为1则表示逐行聚合：

df_demo.mean(axis=1).head() # 在这个数据集上体重和身高的均值并没有意义

0    102.45
1    118.25
2    138.95
3     41.00
4    124.00
dtype: float64

第4行对应的数据的Height值缺失

3. 唯一值函数

对序列使用unique和nunique可以分别得到其唯一值组成的列表和唯一值的个数：

df['School'].unique()
array(['Shanghai Jiao Tong University', 'Peking University',
       'Fudan University', 'Tsinghua University'], dtype=object)

df['School'].nunique()
4

value_counts可以得到唯一值和其对应出现的频数：

df['School'].value_counts()

Tsinghua University              69
Shanghai Jiao Tong University    57
Fudan University                 40
Peking University                34
Name: School, dtype: int64

如果想要观察多个列组合的唯一值，可以使用drop_duplicates。其中的关键参数是keep，默认值first表示每个组合保留第一次出现的所在行，last表示保留最后一次出现的所在行，False表示把所有重复组合所在的行剔除。

df_demo = df[['Gender','Transfer','Name']]
df_demo.drop_duplicates(['Gender', 'Transfer'])

在这里插入图片描述

df_demo.drop_duplicates(['Gender', 'Transfer'], keep='last')

在这里插入图片描述

df_demo.drop_duplicates(['Name', 'Gender'], keep=False).head() # 保留只出现过一次的性别和姓名组合

在这里插入图片描述

df['School'].drop_duplicates() # 在Series上也可以使用

0    Shanghai Jiao Tong University
1                Peking University
3                 Fudan University
5              Tsinghua University
Name: School, dtype: object

此外，duplicated和drop_duplicates的功能类似，但前者返回了是否为唯一值的布尔列表，其keep参数与后者一致。其返回的序列，把重复元素设为True，否则为False。 drop_duplicates等价于把duplicated为True的对应行剔除。

df_demo.duplicated(['Gender', 'Transfer']).head()

0    False
1    False
2     True
3     True
4     True
dtype: bool

df['School'].duplicated().head() # 在Series上也可以使用

0    False
1    False
2     True
3    False
4     True
Name: School, dtype: bool

4. 替换函数

一般而言，替换操作是针对某一个列进行的，因此下面的例子都以Series举例。pandas中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换。

  • 映射替换包含replace方法、第八章中的str.replace方法以及第九章中的cat.codes方法，此处介绍replace的用法。

在replace中，可以通过字典构造，或者传入两个列表来进行替换：

df['Gender'].replace({'Female':0, 'Male':1}).head()
0    0
1    1
2    1
3    0
4    1
Name: Gender, dtype: int64

df['Gender'].replace(['Female', 'Male'], [0, 1]).head()
0    0
1    1
2    1
3    0
4    1
Name: Gender, dtype: int64

另外，replace还有一种特殊的方向替换，指定method参数为ffill则为用前面一个最近的未被替换的值进行替换，bfill则使用后面最近的未被替换的值进行替换。从下面的例子可以看到，它们的结果是不同的：

s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace([1, 2], method='ffill')
0    a
1    a
2    b
3    b
4    b
5    b
6    a
dtype: object

s.replace([1, 2], method='bfill')
0    a
1    b
2    b
3    a
4    a
5    a
6    a
dtype: object

正则替换请使用str.replace（第八章）：虽然对于replace而言可以使用正则替换，但是当前版本下对于string类型的正则替换还存在bug。

  • 逻辑替换包括了where和mask，这两个函数是完全对称的：where函数在传入条件为False的对应行进行替换，而mask在传入条件为True的对应行进行替换，当不指定替换值时，替换为缺失值。
  • where：
s = pd.Series([-1, 1.2345, 100, -50])
s.where(s<0)
0    -1.0
1     NaN
2     NaN
3   -50.0
dtype: float64

s = pd.Series([-1, 1.2345, 100, -50])
s.where(s<0, 100)
0     -1.0
1    100.0
2    100.0
3    -50.0
dtype: float64
  • mask
s = pd.Series([-1, 1.2345, 100, -50])
s.mask(s<0)
0         NaN
1      1.2345
2    100.0000
3         NaN
dtype: float64

s = pd.Series([-1, 1.2345, 100, -50])
s.mask(s<0, -50)
0    -50.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64

需要注意的是，传入的条件只需是与被调用的Series索引一致的布尔序列即可：

s_condition= pd.Series([True,False,False,True],index=s.index)
s.mask(s_condition, -50)

0    -50.0000
1      1.2345
2    100.0000
3    -50.0000
dtype: float64
  • 数值替换包含了round, abs, clip方法，它们分别表示取整、取绝对值和截断：
s = pd.Series([-1, 1.2345, 100, -50])
s.round(2)
0     -1.00
1      1.23
2    100.00
3    -50.00
dtype: float64

s.abs()
0      1.0000
1      1.2345
2    100.0000
3     50.0000
dtype: float64

s.clip(0, 2) # 前两个数分别表示上下截断边界
0    0.0000
1    1.2345
2    2.0000
3    0.0000
dtype: float64
【练一练】

在 clip 中，超过边界的只能截断为边界值，如果要把超出边界的替换为自定义的值，应当如何做？
解：
使用replace对上下界分别进行替换，如上下界依然是（0,2）,超过下边界的替换为666，超过上边界的替换为888：

s = pd.Series([-1, 1.2345, 100, -50])
s.clip(0, 2).replace({0:666, 2:888})

0    666.0000
1      1.2345
2    888.0000
3    666.0000
dtype: float64

5. 排序函数

排序共有两种方式：

  • 值排序sort_values
  • 索引排序sort_index

为了演示排序函数，下面先利用set_index方法把年级和姓名两列作为索引，多级索引的内容和索引设置的方法将在第三章进行详细讲解。

df_demo = df[['Grade', 'Name', 'Height', 'Weight']].set_index(['Grade','Name'])
df_demo.head()

在这里插入图片描述

对身高进行排序，默认参数ascending=True为升序：

df_demo.sort_values('Height').head()

在这里插入图片描述

df_demo.sort_values('Height', ascending=False).head()

在这里插入图片描述
在排序中，进场遇到多列排序的问题，比如在体重相同的情况下，对身高进行排序，并且保持身高降序排列，体重升序排列：

df_demo.sort_values(['Weight','Height'],ascending=[True,False]).head()

在这里插入图片描述
索引排序的用法和值排序完全一致，只不过元素的值在索引中，此时需要指定索引层的名字或者层号，用参数level表示。另外，需要注意的是字符串的排列顺序由字母顺序决定。

df_demo.sort_index(level=['Grade','Name'],ascending=[True,False]).head()

在这里插入图片描述

6. apply方法

apply方法常用于DataFrame的行迭代或者列迭代，它的axis含义与第2小节中的统计聚合函数一致，apply的参数往往是一个以序列为输入的函数。例如对于.mean()，使用apply可以如下地写出：

df_demo = df[['Height', 'Weight']]
def my_mean(x):
     res = x.mean()
     return res
df_demo.apply(my_mean)

Height    163.218033
Weight     55.015873
dtype: float64

同样的，可以利用lambda表达式使得书写简洁，这里的x就指代被调用的df_demo表中逐个输入的序列：

df_demo.apply(lambda x:x.mean())

Height    163.218033
Weight     55.015873
dtype: float64

若指定axis=1，那么每次传入函数的就是行元素组成的Series，其结果与之前的逐行均值结果一致。

df_demo.apply(lambda x:x.mean(), axis=1).head()

0    102.45
1    118.25
2    138.95
3     41.00
4    124.00
dtype: float64

mad函数返回的是一个序列中偏离该序列均值的绝对值大小的均值。
例如序列1,3,7,10中，均值为5.25，每一个元素偏离的绝对值为4.25,2.25,1.75,4.75，这个偏离序列的均值为3.25。现在利用apply计算升高和体重的mad指标：

df_demo.apply(lambda x:(x-x.mean()).abs().mean())

Height     6.707229
Weight    10.391870
dtype: float64

使用内置的mad函数：

df_demo.mad()

Height     6.707229
Weight    10.391870
dtype: float64

两种方法计算结果一致。
谨慎使用apply：
得益于传入自定义函数的处理，apply的自由度很高，但这是以性能为代价的。一般而言，使用pandas的内置函数处理和apply来处理同一个任务，其速度会相差较多，因此只有在确实存在自定义需求的情境下才考虑使用apply。

四、窗口对象

pandas中有3类窗口，分别是滑动窗口rolling、扩张窗口expanding以及指数加权窗口ewm。需要说明的是，以日期偏置为窗口大小的滑动窗口将在第十章讨论，指数加权窗口见本章练习。

1. 滑窗对象

要使用滑窗函数，就必须先要对一个序列使用.rolling得到滑窗对象，其最重要的参数为窗口大小window。

s = pd.Series([1,2,3,4,5])
roller = s.rolling(window = 3)
roller

Rolling [window=3,center=False,axis=0]

在得到了滑窗对象后，能够使用相应的聚合函数进行计算，需要注意的是窗口包含当前行所在的元素，例如在第四个位置进行均值运算时，应当计算(2+3+4)/3，而不是(1+2+3)/3：

roller.mean()

0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64

roller.sum()

0     NaN
1     NaN
2     6.0
3     9.0
4    12.0
dtype: float64

对于滑动相关系数或滑动协方差的计算，可以如下写出：

s2 = pd.Series([1,2,6,16,30])

roller.cov(s2)
0     NaN
1     NaN
2     2.5
3     7.0
4    12.0
dtype: float64

roller.corr(s2)

0         NaN
1         NaN
2    0.944911
3    0.970725
4    0.995402
dtype: float64

此外，还支持使用apply传入自定义函数，其传入值是对应窗口的Series，例如上述的均值函数可以等效表示：

roller.apply(lambda x:x.mean())

0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64

shift, diff, pct_change是一组类滑窗函数，它们的公共参数为periods=n，默认为1，分别表示取向前第n个元素的值、与向前第n个元素做差（与Numpy中不同，后者表示n阶差分）、与向前第n个元素相比计算增长率。这里的n可以为负，表示反方向的类似操作。

  • shift：
s = pd.Series([1,3,6,10,15])
s.shift(2)

0    NaN
1    NaN
2    1.0
3    3.0
4    6.0
dtype: float64

s.shift(-1)

0     3.0
1     6.0
2    10.0
3    15.0
4     NaN
dtype: float64
  • diff：
s.diff(3)

0     NaN
1     NaN
2     NaN
3     9.0
4    12.0
dtype: float64

s.diff(-2)

0   -5.0
1   -7.0
2   -9.0
3    NaN
4    NaN
dtype: float64
  • pct_change：
s.pct_change()

0         NaN
1    2.000000
2    1.000000
3    0.666667
4    0.500000
dtype: float64

将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为n+1的rolling方法等价代替：

s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)

0    NaN
1    NaN
2    1.0
3    3.0
4    6.0
dtype: float64

 s.rolling(4).apply(lambda x:list(x)[-1]-list(x)[0]) # s.diff(3)
 
0     NaN
1     NaN
2     NaN
3     9.0
4    12.0
dtype: float64

def my_pct(x):
     L = list(x)
     return L[-1]/L[0]-1
s.rolling(2).apply(my_pct) # s.pct_change()

0         NaN
1    2.000000
2    1.000000
3    0.666667
4    0.500000
dtype: float64
【练一练】

rolling对象的默认窗口方向都是向前的，某些情况下用户需要向后的窗口，例如对1,2,3设定向后窗口为2的sum操作，结果为3,5,NaN，此时应该如何实现向后的滑窗操作？（提示：使用shift）
解：

s = pd.Series([1, 2, 3])
sum2 = s.shift(-1)+s
sum2

0    3.0
1    5.0
2    NaN
dtype: float64

2. 扩张窗口

扩张窗口又称累计窗口，可以理解为一个动态长度的窗口，其窗口的大小就是从序列开始处到具体操作的对应位置，其使用的聚合函数会作用于这些逐步扩张的窗口上。具体地说，设序列为a1, a2, a3, a4，则其每个位置对应的窗口即[a1]、[a1, a2]、[a1, a2, a3]、[a1, a2, a3, a4]。

s = pd.Series([1, 3, 6, 10])
s.expanding().mean()

0    1.000000
1    2.000000
2    3.333333
3    5.000000
dtype: float64
【练一练】

cummax, cumsum, cumprod函数是典型的类扩张窗口函数，请使用expanding对象依次实现它们。
解：

s = pd.Series([1, 3, 6, 10])
s.cummax()
0     1
1     3
2     6
3    10
dtype: int64

s.expanding().max()
0     1.0
1     3.0
2     6.0
3    10.0
dtype: float64

s = pd.Series([1, 3, 6, 10])
s.cumsum()
0     1
1     4
2    10
3    20
dtype: int64

s.expanding().sum()
0     1.0
1     4.0
2    10.0
3    20.0
dtype: float64

s = pd.Series([1, 3, 6, 10])
s.cumprod()
0      1
1      3
2     18
3    180
dtype: int64

def my_prod(x):
    result = 1
    L = list(x)
    for x in L:
         result = result * x  
    return result  
s.expanding().apply(my_prod)
0      1.0
1      3.0
2     18.0
3    180.0
dtype: float64

五、练习

Ex1：口袋妖怪数据集

现有一份口袋妖怪的数据集，下面进行一些背景说明：

  • #代表全国图鉴编号，不同行存在相同数字则表示为该妖怪的不同状态

  • 妖怪具有单属性和双属性两种，对于单属性的妖怪，Type 2为缺失值

  • Total, HP, Attack, Defense, Sp. Atk, Sp. Def, Speed分别代表种族值、体力、物攻、防御、特攻、特防、速度，其中种族值为后6项之和
    在这里插入图片描述

  1. 对HP, Attack, Defense, Sp. Atk, Sp. Def, Speed进行加总，验证是否为Total值。
    解：
df_eg1 = df[df.columns[5:]]
df_eg1_sum = df_eg1.sum(1)
df_eg1_sum-df[df.columns[4]]

0      0
1      0
2      0
3      0
4      0
      ..
795    0
796    0
797    0
798    0
799    0
Length: 800, dtype: int64
  1. 对于#重复的妖怪只保留第一条记录，解决以下问题：
    解：
df_qch = df.drop_duplicates('#')
df_qch.head()

在这里插入图片描述

  • 求第一属性的种类数量和前三多数量对应的种类
    解：
df_qch['Type 1'].nunique()

18

df_qch['Type 1'].value_counts()
Water       105
Normal       93
Grass        66
Bug          63
Psychic      47
Fire         47
Rock         41
Electric     36
Ground       30
Dark         28
Poison       28
Fighting     25
Dragon       24
Ice          23
Ghost        23
Steel        22
Fairy        17
Flying        3
Name: Type 1, dtype: int64

df_qch['Type 1'].value_counts().index[:3]
Index(['Water', 'Normal', 'Grass'], dtype='object')
  • 求第一属性和第二属性的组合种类
    解：
df_qch.drop_duplicates(['Type 1','Type 2']).shape[0]

143
  • 求尚未出现过的属性组合
    解：
L_full = [i+' '+j for i in df_qch['Type 1'].unique() for j in (df_qch['Type 1'].unique().tolist() + [''])]
L_part = [i+' '+j for i, j in zip(df_qch['Type 1'], df['Type 2'].replace(np.nan, ''))]
res = set(L_full).difference(set(L_part))
len(res) 

199
  1. 按照下述要求，构造Series：
  • 取出物攻，超过120的替换为high，不足50的替换为low，否则设为mid
    解：
df['Attack'].mask(df['Attack']>120, 'high').mask(df['Attack']<50, 'low').mask((50<=df['Attack'])&(df['Attack']<=120), 'mid').head()

0    low
1    mid
2    mid
3    mid
4    mid
Name: Attack, dtype: object
  • 取出第一属性，分别用replace和apply替换所有字母为大写
    解：
df['Type 1'].replace({i:str.upper(i) for i in df['Type 1'].unique()})

0        GRASS
1        GRASS
2        GRASS
3        GRASS
4         FIRE
        ...   
795       ROCK
796       ROCK
797    PSYCHIC
798    PSYCHIC
799       FIRE
Name: Type 1, Length: 800, dtype: object

df['Type 1'].apply(lambda x:str.upper(x))

0        GRASS
1        GRASS
2        GRASS
3        GRASS
4         FIRE
        ...   
795       ROCK
796       ROCK
797    PSYCHIC
798    PSYCHIC
799       FIRE
Name: Type 1, Length: 800, dtype: object
(c)
  • 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到df并从大到小排序
    解：
df['Deviation'] = df[['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']].apply(lambda x:np.max((x-x.median()).abs()), 1)
df.sort_values('Deviation', ascending=False).head()

在这里插入图片描述

Ex2：指数加权窗口

  1. 作为扩张窗口的ewm窗口

在扩张窗口中，用户可以使用各类函数进行历史的累计指标统计，但这些内置的统计函数往往把窗口中的所有元素赋予了同样的权重。事实上，可以给出不同的权重来赋给窗口中的元素，指数加权窗口就是这样一种特殊的扩张窗口。

其中，最重要的参数是alpha，它决定了默认情况下的窗口权重为 w i = ( 1 − α ) i , i ∈ { 0 , 1 , . . . , t } w_i=(1−\alpha)^i,i\in\{0,1,...,t\} wi​=(1−α)i,i∈{0,1,...,t}，其中 i = t i=t i=t表示当前元素， i = 0 i=0 i=0表示序列的第一个元素。

从权重公式可以看出，离开当前值越远则权重越小，若记原序列为 x x x，更新后的当前元素为 y t y_t yt​，此时通过加权公式归一化后可知：
在这里插入图片描述

对于Series而言，可以用ewm对象如下计算指数平滑后的序列：
在这里插入图片描述
请用expanding窗口实现。
解：

np.random.seed(0)
s = pd.Series(np.random.randint(-1,2,30).cumsum())
s.ewm(alpha=0.2).mean().head()

0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64

def ewm_func(x, alpha=0.2):
    win = (1-alpha)**np.arange(x.shape[0])[::-1]
    res = (win*x).sum()/win.sum()
    return res
s.expanding().apply(ewm_func).head()

0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64
  1. 作为滑动窗口的ewm窗口

从第1问中可以看到，ewm作为一种扩张窗口的特例，只能从序列的第一个元素开始加权。现在希望给定一个限制窗口n，只对包含自身最近的n个窗口进行滑动加权平滑。请根据滑窗函数，给出新的wi与yt的更新公式，并通过rolling窗口实现这一功能。
解：
新的权重为 w i = ( 1 − α ) i , i ∈ { 0 , 1 , . . . , n − 1 } w_i = (1 - \alpha)^i, i\in \{0,1,...,n-1\} wi​=(1−α)i,i∈{0,1,...,n−1}， y t y_t yt​更新如下：
在这里插入图片描述

s.rolling(window=4).apply(ewm_func).head() # 无需对原函数改动

0         NaN
1         NaN
2         NaN
3   -1.609756
4   -1.826558
dtype: float64
【AI全栈三】语音质量算法、评价指标 看一篇就够系列（附算法源码+干货）
cv君的博客
05-16 1万+
文章目录那么我们过去是怎么评价的？客观评价-基于指标客观评价-基于模型R&S®UPV音频分析仪小结那么我们现在用哪些评价方法呢？基于深度学习的方法：AutoMOS， QualityNe, NISQA, MOSNetMOSNet（`absolute.mosnet`或`mosnet`）语音质量的感知评估(Perceptual evaluation of speech quality, PESQ)客观语音质量评估的单端方法P.563预处理特征参数提取失真类型判决和结果映射客观评价结果的映射模型NISQA:
《Hands_On_LLM》8.2 RAG: 利用语言模型进行语义搜索（Semantic Search with Language Models）
最新发布
zg_hover的专栏
01-19 958
现在，让我们深入探讨可以提升语言模型搜索能力的主要系统类别。我们先从高密度检索开始，然后再讨论重排和RAG。
Python 利用pandas处理CSV文件（DataFrame的基础用法）
Vincent的博客
07-09 2万+
pandas是一个第三方数据分析库，其集成了大量的数据分析工具，可以方便的处理和分析各类数据。
pandas零基础教程（1）------ 学习使用pandas来读取csv文件数据
k66777的博客
10-04 214
本文简单介绍了使用pandas读取csv文件数据，并输出你所看到的前6行数据。
【Pandas】pandas.read_csv 详解与实战应用：从CSV文件中读取数据
科技改变人类，技术成就未来
08-01 2175
在数据分析与科学中，CSV（Comma-Separated Values，逗号分隔值）是最常见的数据存储格式之一。Pandas 提供了强大的 read_csv 函数来读取 CSV 文件并将其转换为 DataFrame。这篇博客将详细讲解 read_csv 方法，包括其作用、使用方法、参数详解、示例代码以及注意事项。
Pandas数据的输入与输出：CSV文件
shield911的博客
05-03 9390
Pandas输入输出数据详解，本文讲解CSV文件的读和写。
pandas 基础
weixin_48626051的博客
12-18 834
Pandas 基础 2.1  文件的读取和写入2.1.1  文件读取2.1.2  数据写入3.1  基本数据结构3.1.1  Series3.1.2  DataFrame4.1  常用基本函数4.1.1  汇总函数4.1.2  特征统计函数4.1.3  唯一值函数4.1.4  替换函数4.1
BER-DAFT-MAR21:3月21日柏林数据分析小组的主要官方资料库将包含课程笔记，实验室解决方案以及缩放记录的链接
03-16
课程笔记是本次活动的核心部分，记录了讲座的关键概念和理论，涵盖了数据分析的基础到进阶知识。可能包括统计学基础、数据清洗、数据可视化、预测建模等主题。这些笔记有助于回顾课程内容，巩固学习，并为那些未能...
暑期组队学习计划
Datawhale
07-29 863
Datawhale暑期组队学习计划马上就要开始啦这次共组织15个组队学习涵盖了AI领域从理论知识到动手实践的内容按照下面给出的最完备学习路线分类难度系数分为低、中、高三档...
java高并发程序设计：JUC
qq_42673707的博客
09-08 537
《实战java高并发程序设计》第三章草记 文章目录《实战java高并发程序设计》第三章草记前言一、多线程的团队协作：同步控制1.1重入锁一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 本文为作者学
【Pandas学习笔记Task02】：pandas基础
m0_47105444的博客
12-19 665
【Pandas学习笔记Task02】：pandas基础一、pandas数据结构1.Series2.DataFrame3、对DataFrame行列的访问二、常用函数1.汇总函数2.特征统计函数3.唯一值函数4.替换函数5.排序函数练习Ex1：口袋妖怪数据集总结 一、pandas数据结构 pandas的基本数据结构,包括一维的Series和二维的DataFrame。Series可以理解为一个字典，DataFrame就是Series的一个扩展。 1.Series s = pd.Series(data = [10
pandas学习 task09
qq_41834327的博客
01-07 277
import pandas as pd import numpy as np cat对象 cat对象的属性 pandas提供了category类型以便于用户处理分类类型的变量,将一个序列转换成分类变量可以使用astype方法.分类类型的Series中定义了cat对象,该对象类似于str定义了一些属性和方法来进行分类类别的操作.对于一个具体的分类,有两个组成部分,其一为类别的本身,它以Index类型存储,其二为是否有序,它们都可以通过cat的属性被访问.除此之外,每一个序列的类别都会被赋予唯一的整数编号,它
Pandas学习笔记之二——Pandas基础
lzzqj的博客
12-19 386
仅以此文记录我的Pandas学习过程，，今天分享的是Pandas基础欢迎大家交流。 Pandas基础部分主要包括文件的读取和写入、基本数据结构、常用基本函数、窗口对象以及最后的练习部分。 一、文件的读取和写入 标题 二、基本数据结构 三、常用基本函数 四、窗口对象 五、练习 ...
Pandas语法笔记（二）pandas基础
qq_36744449的博客
05-13 598
https://github.com/datawhalechina/joyful-pandas 第二章 pandas基础 In [1]: import numpy as np In [2]: import pandas as pd 在开始学习前，请保证 pandas 的版本号不低于如下所示的版本，否则请务必升级！请确认已经安装了 xlrd, xlwt, openpyxl 这三个包，其中xlrd版本不得高于 2.0.0 。 In [3]: pd.__version__ Out[3]: '1.2.0'
pandas基础
qq_41358220的博客
12-19 334
一.文件的读写 数据获取地址 1.文件的读取 pandas可以读取的文件格式有很多，这里主要介绍读取csv, excel, txt文件。 df_csv = pd.read_csv('../data/my_csv.csv') # 读取csv文件 df_csv df_txt = pd.read_table('../data/my_table.txt') # 读取txt文件 df_txt df_excel = pd.read_excel('../data/my_excel.xlsx') # 读取exce
Task 2 pandas基础
XYQLTX的博客
12-19 548
一、作业 df = pd.read_csv('../joyful-pandas-master/data/pokemon.csv') df.head() #1.对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值。 total1 = df[['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed']].sum(1) (total1 == df['Total']).sum() == df[
index_col的用法
热门推荐
hellocsz的博客
06-11 3万+
读取excel文件 read_excel 1.index_col 默认值（index_col = None）——重新设置一列成为index值 2.index_col=False——重新设置一列成为index值 3.index_col=0——第一列为index值 index_col=0，将第一列变为index。 读取csv文件 read_csv lines = pd.read_csv(c...
pandas read_csv参数index_col = None,0,False的区别
hello world
01-22 1万+
前言 网上好多对index_col的解释都有点别扭，基本都是将False和None等同起来了。（都是重新设置一列成为index值），所以我去谷歌了解了一下。 介绍 pandas是python中的一个库，read_csv是pandas的读取csv数据的一个函数。而index_col是read_csv中的一个参数。用来指定表格的索引值。 来看下pandas官方文档是怎么定义index_col的： index_col : int, sequence or bool, optional Column t
python读取表格,行列对齐,设置打印宽度,index_col方法,读0,1行并命名索引行,求最大小值,极差
qq_46318765的博客
04-12 1981
import pandas as pd import numpy as np import datetime pd.set_option(‘display.unicode.ambiguous_as_wide’, True) pd.set_option(‘display.unicode.east_asian_width’, True) # 行列对齐 pd.set_option(‘display.w...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值