Task 2 pandas基础
一、作业
1.1
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['Total'].shape[0]#True
# 2 对于 # 重复的妖怪只保留第一条记录，解决以下问题：
#a. 求第一属性的种类数量和前三多数量对应的种类
df_demo = df.drop_duplicates(['#'])
df_demo['Type 1'].nunique()#第一属性的种类数量为18
df_demo['Type 1'].value_counts()[:3]
#Water 105
#Normal 93
#Grass 66
#Name: Type 1, dtype: int64
#前三多数量对应的种类为：Water,Normal,Grass
#b.求第一属性和第二属性的组合种类
df_demo[['Type 1','Type 2']].drop_duplicates().shape[0]#143
#c.求尚未出现过的属性组合
1.2
#按照下述要求，构造 Series ：
#a 取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
s = df['Attack']
s.mask(s>120,'high').mask(s<=50,'low').mask((50<s) &(s<=120),'mid')
#b 取出第一属性，分别用 replace 和 apply 替换所有字母为大写
s1 = df['Type 1']
s1.apply(lambda x : x.upper())
s1.replace(s1.values,[i.upper() for i in list(s1)])
#c 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
df_demo1 = df[['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed']]
df_mid = df_demo1.median(1)#为什么不能先算这个，然后直接相减呢，
#df_demo1 - df_demo1.median(1)的值为什么会是800*800的NAN值
df['Licha'] = df_demo1.apply(lambda x: ((x - df_demo1.median())).abs().max(),axis=1)
df.sort_values('Licha', ascending=False)
np.random.seed(0)
s = pd.Series(np.random.randint(-1,2,30).cumsum())
s.head()
s.ewm(alpha=0.2).mean()
## 用expanding
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)
s.rolling(window=4).apply(ewm_func)
二、pandas基础
2.1 文件的读取和写入
1 文件读取
df_csv = pd.read_csv('../joyful-pandas-master/data/my_csv.csv')#相对路径，..表示返回上一层，后面的路径为进入的路径名
df_csv#路径不能有中文名
df_txt = pd.read_table('../joyful-pandas-master/data/my_table.txt')
df_txt
df_excel = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx')
print(df_excel)
header=None 表示第一行不作为列名,列名而是以序号表示， index_col表示把某一列或几列作为索引，
usecols 表示读取列的集合,默认读取所有的列，parse_dates 表示需要转化为时间序列，
nrows 表示读取的数据行数。上面这些参数在上述的三个函数里都可以
df_excel1 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',header=None)
df_excel1
df_excel2 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',index_col=[0,3])
#可以直接用序号，也可用第一行的内容索引
df_excel2
#df_excel3 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',index_col=['col1','col2'])
#df_excel3#报错了
df_excel4 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',usecols=[0,3])
df_excel4#只显示读取的列
df_excel5 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',parse_dates=[4])
df_excel5#转换时间的格式
df_excel6 = pd.read_excel('../joyful-pandas-master/data/my_excel.xlsx',nrows=2)
df_excel6#格式为nrows=2这种，数为几就会读取前几行。
在读取 txt 文件时，经常遇到分隔符非空格的情况，例如，下面的读取的表以 |||| 为分割
df_txt1 = pd.read_table('../joyful-pandas-master/data/my_table_special_sep.txt')
df_txt1#col1 |||| col2
#0 TS |||| This is an apple.
#上面的结果显然不是理想的，这时可以使用 sep ，同时需要指定引擎为 python ：
df_txt2 = pd.read_table('../joyful-pandas-master/data/my_table_special_sep.txt',sep='\|\|\|\|',engine='python')
df_txt2#col1 col2
#0 TS This is an apple.如果少了一个\|就还会留下一个|
#sep 是正则参数,在使用 read_table 的时候需要注意,参数sep中使用的是正则表达式，
#因此需要对\进行转义变成\| ，否则无法读取到正确的结果。
2 数据写入即把变量内容进行保存，一般在数据写入中，最常用的操作是把index设置为False，
特别当索引没有特殊意义的时候，这样的行为能把索引在保存的时候去除。
df_excel1.to_csv('../joyful-pandas-master/data/myexcel1.csv',index=False)
#pandas中没有定义to_table函数，但是to_csv可以保存为txt文件，并且允许自定义分隔符，常用制表符 \t 分割
df_txt2.to_csv('../joyful-pandas-master/data/my_txt2.txt',sep='\t',index=False)
2.2 基本数据结构
Pandas中具有两种基本的数据存储结构，存储一维values的Series和存储二维values的DataFrame,在这两种结构上定义了很多的属性和方法。
- 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.index#Index(['id1', 20, 'third'], dtype='object', name='my_idx')
利用 .shape 可以获取序列的长度：
#利用 .shape 可以获取序列的长度：
print(s.values)#[100 'a' {'dic1': 5}],注意值是values
s.shape#(3,)
#如果想要取出单个索引对应的值，可以通过 [index_item] 可以取出。
s['third']#{'dic1': 5}
- DataFrame,在Series的基础上增加了列索引,一个数据框可以由二维的data与行列索引来构造,没有dtype和name.
data = [[1,'a',1.2],[2,'b',2.2],[3,'c',3.2]]
DF = pd.DataFrame(data,index=['row_%d'%i for i in range(3)],
columns= ['col_%d'%i for i in range(3)])
DF
更多的时候会采用从列索引名到数据的映射来构造数据框，同时再加上行索引：
DF1 = 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)])#注意此时data为字典
DF1
DF['col_0']#为Series
DF[['col_0','col_1']]
与 Series 类似，在数据框中同样可以取出相应的属性：
DF.values#array([[1, 'a', 1.2],
# [2, 'b', 2.2],
# [3, 'c', 3.2]], dtype=object)
DF.columns#Index(['col_0', 'col_1', 'col_2'], dtype='object')
DF.dtypes#col_0 int64## 返回的是值为相应列数据类型的Series
#col_1 object
#col_2 float64
#dtype: object
DF.shape#(3, 3)
#通过.T可以进行转置
DF.T
2.3 常用基本函数
PS：
df = pd.read_csv('../joyful-pandas-master/data/learn_pandas.csv')
df.columns#Index(['School', 'Grade', 'Name', 'Gender', 'Height', 'Weight', 'Transfer'], dtype='object')
df = df[df.columns[:7]]
df#使用前7列
df1 = pd.read_csv('../joyful-pandas-master/data/learn_pandas.csv',usecols=range(7))
df1.columns#与df.columns一致
1 汇总函数
head, tail 函数分别表示返回表或者序列的前 n 行和后 n 行，其中 n 默认为5：
df.head()#0-4
df.head(2)
df.tail()
df.tail(3)
info, describe 分别返回表的信息概况和表中数值列float对应的主要统计量 ：
df.info()
df.describe()
2 特征统计函数
在 Series 和 DataFrame 上定义了许多统计函数，最常见的是 sum, mean, median, var, std, max, min
df_demo = df[['Height','Weight']]
df_demo.mean()
df_demo.std()
# quantile, count, idxmax 这三个函数，它们分别返回的是分位数、非缺失值个数、最大值对应的索引
df_demo.quantile(0.5)#Height 161.9
#Weight 51.0
#Name: 0.5, dtype: float64
df_demo.count()#Height 183
#Weight 189
#dtype: int64
df_demo.idxmax()#Height 193
#Weight 2
#dtype: int64
上面这些所有的函数，由于操作后返回的是标量，所以又称为聚合函数，它们有一个公共参数 axis ，
默认为0代表逐列聚合，如果设置为1则表示逐行聚合：
df_demo.quantile(0.5,axis=1)
df_demo.mean(axis=1).head()
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_demo1 = df[['Gender','Transfer','Name']]
df_demo1.drop_duplicates(['Gender','Transfer'])
df_demo1.drop_duplicates(['Gender','Transfer'],keep='last')
df_demo1.drop_duplicates(['Gender','Name'],keep=False)
df_demo1[['Gender','Name']].duplicated()#等价于
df_demo1.duplicated(['Gender','Name'])
4 替换函数
替换操作是针对某一个列进行的，因此下面的例子都以 Series 举例。 pandas 中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换
在 replace 中，可以通过字典构造，或者传入两个列表来进行替换：
df['Gender'].replace({'Female':0,'Male':1})
df['Gender'].replace(['Female','Male'],[0,1])
#df['School']['Fudan University'].replace(['ZhongShan University'])#报错，只想替换一个人的信息怎么弄？？？？
replace还有一种特殊的方向替换，指定method参数为ffill则为用前面一个最近的未被替换的值进行替换，bfill 则使用后面最近的未被替换的值进行替换
s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
print(s)
s.replace([1,2],method='ffill')#pd.Series(['a','a','b','b','b','b','a'])，
#1要被替换，前面没被替换最#近的是‘a’,而后2要被替换。它前面没被替换最近的是‘b’,后面两个1也是‘b’，
s.replace([1,2],method='bfill')#pd.Series(['a','b','b','a','a','a','a'])
逻辑替换包括了 where 和 mask ，这两个函数是完全对称的： where 函数在传入条件为 False 的对应行进行替换，而 mask 在传入条件为 True 的对应行进行替换，当不指定替换值时，替换为缺失值。
s1 = pd.Series([-1,2,2.5,-0.8,3.7])
s1.where(s1<0,0)#pd.Series([-1,0,0.0,-0.8,0])
s1.mask(s1<0,0)#pd.Series([-0,2,2.5,0,3.7])
s1.mask(s1<0)#pd.Series([ NaN,2,2.5, NaN,3.7])
#需要注意的是，传入的条件只需是与被调用的 Series 索引一致的布尔序列即可
s_condition= pd.Series([True,False,False,True])
s1.mask(s_condition)#pd.Series([ NaN,2,2.5, NaN,NaN])
#数值替换包含了round, abs, clip 方法，它们分别表示按照给定精度四舍五入、取绝对值和截断：
s2 = pd.Series([1,2.353,-59.530,68.429,-2.10])
s2.round(2)#括号能参数表示保留几位小数,pd.Series([1.00,2.35,-59.53,68.43,-2.10])
s2.abs()#pd.Series([1,2.353,59.530,68.429,2.10])
s2.clip(-10,10)#pd.Series([1,2.353,-10,10,-2.10])
5 排序函数
排序共有两种方式，其一为值排序，其二为索引排序，对应的函数是 sort_values 和 sort_index
df_demo = df[['Grade','Name','Height','Weight']].set_index(['Grade','Name'])
#sort_values中默认参数 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()
#按列表索引的先后顺序来，先是weight,因此先按weight，而weight中有相同的，而后再根据height排序，而且
#weight中相同时，height按降序排
#索引排序的用法和值排序完全一致，只不过元素的值在索引中，此时需要指定索引层的名字或者层号，用参数 level 表示。
#另外，需要注意的是字符串的排列顺序由字母顺序决定。
df_demo.sort_index(level=['Grade','Name'],ascending=[True,False]).head()
6 apply方法
apply 方法常用于 DataFrame 的行迭代或者列迭代，apply 的参数往往是一个以序列为输入的函数。
参数axis = 0 默认为列传入。axis = 1，传入函数的就是行元素组成的 Series
df_demo = df[['Height', 'Weight']]
df_demo.apply(lambda x:x.mean())
#Height 163.218033
#Weight 55.015873
#dtype: float64
2.4 窗口对象
所谓的窗口其实可以理解为平滑的长度。我的理解是，原来的数据，我们都是以一个值作为一个对象整体，而滑窗对象是以一个窗口长度所包含的值作为一个对象整体。
- 滑窗对象
要使用滑窗函数，就必须先要对一个序列使用 .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
支持使用 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 可以为负，表示反方向的类似操作。
s = pd.Series([1,3,6,10,15])
s.shift(2)
#0 NaN # 第一个取前面2个的值，没有值
#1 NaN #第2个取前面2个的值，没有值
#2 1.0 #第3个为6取前面2个值也就是1
#3 3.0
#4 6.0
#dtype: float64
s.diff(3)
#0 NaN # 第一个减前面3个的值，没有值
#1 NaN # 第2个减前面3个的值，没有值
#2 NaN # 第3个减前面3个的值，没有值
#3 9.0 # 第4个减前面3个的值，为10-1=9
#4 12.0
#dtype: float64
In [107]: s.pct_change()
#0 NaN
#1 2.000000
#2 1.000000
#3 0.666667
#4 0.500000
#dtype: float64
In [108]: s.shift(-1)
#0 3.0
#1 6.0
#2 10.0
#3 15.0
#4 NaN
#dtype: float64
#s.diff(-2)
#0 -5.0
#1 -7.0
#2 -9.0
#3 NaN
#4 NaN
#dtype: float64
将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为 n+1 (因为都是往前n个，再加上自己本身，所以是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
- 扩张窗口
扩张窗口又称累计窗口，可以理解为一个动态长度的窗口，其窗口的大小就是从序列开始处到具体操作的对应位置，其使用的聚合函数会作用于这些逐步扩张的窗口上。具体地说，设序列为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