pandas_01

# Pandas 知识点总结
# Pandas数据结构：Series 和 DataFrame
import pandas as pd
import numpy as np

# 一，Series:

# 1, 创建 Series  pd.Series(列表或字典)
# 1）使用列表创建Series:
# 1-1）使用列表创建 Series，默认索引为从 0开始的数字:
s_obj = pd.Series([4,7,-5,3])
s_obj
# 0    4
# 1    7
# 2   -5
# 3    3
# dtype: int64

# 1-2) 使用列表创建 Series，指定索引:
s_obj2=pd.Series([4,7,-5,3],index=['d','b','a','c'])
s_obj2
# d    4
# b    7
# a   -5
# c    3
# dtype: int64

# 2) 使用字典创建 Series：
# 2-1）使用字典创建 Series,默认索引为字典的键:
sdata={'Ohio':35000,'texas':71000,'Oregon':16000,'Utah':1000}
s_obj3=pd.Series(sdata)  # 产生一个按【键】排好序的字典。
s_obj3
# Ohio      35000
# texas     71000
# Oregon    16000
# Utah       1000
# dtype: int64

# 2-2）使用字典创建 Series，指定索引：
# 当新定义的键在原字典中不存在时，Series处理这个缺失值为NaN。
# 当原来的字典中的键不存在于新定义的索引列表中时，这个键值对就会被排除掉。
sdata={'Ohio':35000,'texas':71000,'Oregon':16000,'Utah':1000}
s_obj4=pd.Series(sdata,index=["Tom",'Ohio','Ivan','Utah','Collin'])
s_obj4
# Tom           NaN
# Ohio      35000.0
# Ivan          NaN
# Utah       1000.0
# Collin        NaN

s_obj.values  # Series的值数组     array([ 4,  7, -5,  3], dtype=int64)
s_obj.index   # Series的索引对象   RangeIndex(start=0, stop=4, step=1)

# 2, 修改索引：
# 使用 Series_obj.index属性，按【位置】赋值创建/改变索引：
s_obj2=pd.Series([4,7,-5,3],index=['d','b','a','c'])
s_obj2.index=['m','b','a','d']  # 长度必须与 序列的 size一致，否则报错。
s_obj2
# m    4
# b    7
# a   -5
# d    3
# dtype: int64

# 3, 使用索引访问和修改序列元素
s_obj[2]     # -5  
s_obj2['a']  # -5  使用行标签进行索引
s_obj2[2]    # -5  使用行号进行索引
s_obj2[2]=0  
s_obj2  
# m    4
# b    7
# a    0
# d    3
# dtype: int64

# 4, 使用 numpy函数操作 series对象
# 对Series对象使用 Numpy 函数或 Numpy 风格的各种操作（如根据布尔型数组进行过滤，与标量相乘，或者应用数学函数），
# 都会保留索引与值之间的连接关系:

s_obj2[obj2>0] #使用布尔型数组对数组进行索引
s_obj2*2
np.exp(obj2)   #计算各元素的以e为底的指数


# 5, 判断索引是否存在于序列中：
print('Yes') if 'b' in s_obj2 else print('No')
print('Yes') if 'b' in s_obj2.index else print('No')
print('Yes') if 'e' in s_obj2 else print('No') 
print('Yes') if 'e' in s_obj2.index else print('No') 

# 6, 检验缺失数据：isnull()  notnull()函数 
# 既可以作为pandas的顶层函数，也可以作为 Series实例对象调用的方法。
# 对序列中的每个元素进行判断，返回与原数组长度相同的布尔类型 Series对象。
# 在后面的章节中会深入的讨论如何处理缺失数据。

pd.isnull(s_obj4)  # 等同于 s_obj4.isnull()
# Tom        True
# Ohio      False
# Ivan       True
# Utah      False
# Collin     True
# dtype: bool
pd.notnull(s_obj4) # 等同于 s_obj4.notnull()   
# Tom       False
# Ohio       True
# Ivan      False
# Utah       True
# Collin    False
# dtype: bool


# 7, Series的索引自动对齐：
# 比如进行数学计算时，相同索引的元素进行计算，索引不相同的引入 NaN
# Series的索引自动对齐功能和数据库的join操作是很相似的。
s_obj3+s_obj4
# Collin        NaN
# Ivan          NaN
# Ohio      70000.0
# Oregon        NaN
# Tom           NaN
# Utah       2000.0
# texas         NaN
# dtype: float64


# 8, 指定series_obj.name 属性和 Series_obj.index.name 属性的值：
# 可以修改这两个属性(默认为None)，他们往往和pandas的其他重要功能集成在一起。
print(s_obj4.name)         # None
print(s_obj4.index.name)   # None
s_obj4.name="population"   # 人口
s_obj4.index.name="state"  # 州
s_obj4
state
# Tom           NaN
# Ohio      35000.0
# Ivan          NaN
# Utah       1000.0
# Collin        NaN
# Name: population, dtype: float64

# 二，DataFrame

# 定义：表示矩阵数据表，包含已经排序的列集合，每一列可以是不同的值类型（数值，字符串，布尔值等）。
# 特点：
# 1）既有行索引，也有列索引；可以被视为共享相同索引的 Series的字典。
# 2）数据被存储为一个以上的二维块，而不是列表，字典或其他一维数组的集合。

# Note: 尽管 DataFrame是二维的，但可以利用分层索引在DataFrame中展现更高维度的数据。分层索引是pandas中一种更为高级的数据处理特性。
# DataFrame 既可以创建而来，也可以由其他数据类型转化而来。


# 1,创建 DataFrame
# DataFrame 构造函数的有效输入:

# 二维数组 2d ndarray                  数据矩阵，行列的索引标签是可选参数  
# 数组，列表，元组,序列构成的字典      每个序列成为 DataFrame 的一列，所有的序列必须长度相等 
# Numpy 结构化/记录化数组              与数组构成的字典一致
# Series 构成的字典                    每个 Series为一列，Series的索引合并为行索引，也可以显式的传递索引
# 字典构成的字典（嵌套字典）           每一个内部字典形成一列，键联合起来形成结果的行索引 
# 字典或Series构成的列表               列表中的一个元素形成 DataFrame的一行，字典的键 或Series索引联合起来形成 DataFrame的列标签
# 列表或元组构成的列表                 与 2d ndarray的情况一致

# 其他DataFrame                     如果不显式传递索引，则会使用原 DataFrame 的索引
# Numpy MaskedArray                 与 2d ndarray的情况类似，但隐藏值会在结果DataFrame 中成为 NA/缺失值

# 示例：
# 1-1）pd.DataFrame(dict_mixvalue),默认 从0开始的数字为行索引，字典的键为列索引。
data={
    'name':np.array(['张三','李四','王五','小明']),   # 字典的值是 一维数组
    'sex':('female','female','male','male'),          # 字典的值是 一维元组
    'year':[2001,2001,2003,2002],                     # 字典的值是 一维列表
    'city':pd.Series(['北京','上海','广州','深圳'])   # 字典的值是 一维序列
}
df=DataFrame(data)
df
#      name     sex      year     city
# 0    张三    female    2001    北京
# 1    李四    female    2001    上海
# 2    王五    male      2003    广州
# 3    小明    male      2002    深圳


# 1-2）pd.DataFrame(嵌套字典)  # 内层字典的键为行索引，外层字典的键为列索引，
data2={
    'sex':{'张三':'female','李四':'female','王五':'male'},
    'city':{'张三':'北京','李四':'上海','王五':'广州'}
}

df02=DataFrame(data2)
# df02=DataFrame(data2,index=['老大','李四','王五'])   # 显式地指定行/列索引的顺序或改变 行/列数据。
# df02=DataFrame(data2,index=['老大','李四','王五'],columns=['sex','city','newcolumn'])
df02

# 以下方式创建DataFrame对象的方法不再举例：
# 1-7) 使用列表或元组构成的嵌套列表创建 DataFrame 数据
# 1-8) 使用字典列表创建 DataFrame 数据 
# 1-9) 使用Series对象创建 DataFrame 数据
# 1-10) 使用 2dndarray 创建 DataFrame 数据


# 2, 查看行，列索引对象：
df.columns    # Index(['name', 'sex', 'year', 'city'], dtype='object')
df.index      # RangeIndex(start=0, stop=4, step=1)


# 3, 指定列索引列表，对列索引进行排序:
# 虽然上面的df都是按创建时的code 顺序对列进行排列的，但由于字典是无序的，所以为了安全起见，我们创建DataFrame时手动指定修改 列的顺序：
from pandas import DataFrame
import numpy as np
data={
    'name':np.array(['张三','李四','王五','小明']),
    'sex':np.array(['female','female','male','male']),
    'year':np.array([2001,2001,2003,2002]),
    'city':np.array(['北京','上海','广州','深圳'])
}
df02=DataFrame(data,columns=['name','year','sex','city'])  
df02
#      name     year     sex     city
# 0    张三    2001      female   北京
# 1    李四    2001      female   上海
# 2    王五    2003      male     广州
# 3    小明    2002      male     深圳


# 4, 指定行索引列表（没有指定行索引的情况下，默认的行索引是从0到N-1（N为数据长度））
df03=DataFrame(data,columns=['name','year','sex','city'],index=['a','b','c','d'])  # 语法
df03
#      name     year     sex     city
# a    张三    2001      female   北京
# b    李四    2001      female   上海
# c    王五    2003      male     广州
# d    小明    2002      male     深圳

# 如果多指定了【列】（data字典中不存在的），将会以缺失值NaN处理：
# 如果少指定了【列】，生成的DataFrame对象就不含此列数据。
# 如果多指定了【行】或少指定了行，就会报错。
df03=DataFrame(data,columns=['year','sex','city','job'],index=['a','b','c','d'])      # 多指定 job,少指定 name列
df03 
#       year      sex        city      job
# a     2001      female      北京      NaN
# b     2001      female     上海       NaN
# c     2003      male       广州       NaN
# d     2002      male       深圳       NaN
df03=DataFrame(data,columns=['year','sex','city','job'],index=['a','b','c','d','e'])  # 多指定一行
df03  # 报错： ValueError: Shape of passed values is (4, 4), indices imply (5, 4)


# 5, 对 DataFrame的行和列进行索引： 返回 Series对象
# 1）对列的索引直接使用df.[列索引名]或df.列索引名
# 2）对行的索引使用df.loc[行索引名] 或 df.iloc[列索引位置]

df03=DataFrame(data,columns=['name','year','sex','city'],index=['a','b','c','d'])
df03['sex']
df03.sex
# a    female
# b    female
# c      male
# d      male
# Name: sex, dtype: object

df03.loc['b']
# df03.iloc[1]
# name        李四
# year      2001
# sex     female
# city        上海
# Name: b, dtype: object


# 6,给行/列赋值 和 增加新的行/列
# 1)给列赋值和增加新的列：
from pandas import DataFrame
import numpy as np
data={
    'name':np.array(['张三','李四','王五','马六']),
    'sex':np.array(['female','female','male','male']),
    'year':np.array([2001,2001,2003,2002]),
    'city':np.array(['北京','上海','广州','深圳'])
}
df04=DataFrame(data,columns=['name','year','sex','city','job'],index=['张','李','王','马']) 
df04['topic']='Data test'           # 将一个值赋值给一列
df04['number']=np.arange(4.)        # 将一个与列等长度的ndarray数组赋值给一列
df04['job']=['Data Analysis']*4     # 将一个与列等长度的列表赋值给一列
# df04
Series_obj=pd.Series(['Data Analysis dev','Data Analysis im'],index=['马','李'])
df04['job']=Series_obj  # 将一个长度<=列长度的 Series对象赋值给一列， 缺失值处理为NAN，按照 DataFrame的索引排列

Series_obj02=pd.Series(['band 6A','band 8B','band 7B'],index=['马','李','王'])
df04['band']=Series_obj02  # 创建一个新的列。
df04
#              name         year         sex           city          job                  topic            number      band
# 张          张三          2001        female        北京           NaN                 Data test          0.0         NaN
# 李          李四          2001        female        上海    Data Analysis im           Data test          1.0         band 8B
# 王          王五          2003        male           广州           NaN                Data test          2.0         band 7B
# 马          马六          2002        male           深圳    Data Analysis dev         Data test          3.0         band 6A

# 2)给行赋值和增加新的行：
from pandas import DataFrame
import pandas as pd
import numpy as np
data={
    'name':np.array(['张三','李四','王五','马六']),
    'sex':np.array(['female','female','male','male']),
    'year':np.array([2001,2001,2003,2002]),
    'city':np.array(['北京','上海','广州','深圳'])
}
df05=DataFrame(data,columns=['name','year','sex','city','job'],index=['张','李','王','马']) 
Series_obj=pd.Series(['皮七',2004,"大连",'RPA DEV'],['name','year','city','job'])   # 不能使用 columns关键字（不知道为啥）
df05.loc['张']=Series_obj   # 修改原有的行
df05.loc['皮']=Series_obj   # 增加新的行
# df05.iloc[0]=Series_obj   # 修改原有的行  索引值不能超过 原有索引的的长度    df.iloc[索引值] 只能用来修改已有的行，不能创建新的行
# df05.iloc[5]=Series_obj   # 试图创建的行 报错：IndexError: single positional indexer is out-of-bounds
df05
#         name        year        sex       city       job
# 张     皮七         2004     NaN         大连        RPA DEV
# 李     李四         2001     female      上海        NaN
# 王     王五         2003     male        广州        NaN
# 马     马六         2002     male        深圳        NaN
# 皮     皮七         2004     NaN         大连        RPA DEV


# 7, del 关键字 删除DataFrame的列  
# 示例：先增加一列，再删掉：
df05['new']=df05.sex=='female'   # 增加了一列布尔值数据
# df05.new='test'  # df.列索引名的方式不能创建新的列,不报错，但不会成功
del df05['new']


# 8, 复制列得到 Series对象：
series_copy=df05['sex'].copy()  # 显式复制
series_copy[2]='haha'  # 对其修改不影响 df04的 sex列

# 9, DataFrame 的转置   dataframe_obj.T
df05.T

# 10, 修改列索引和行索引的 name属性：
df05.index.name='Name'
df05.columns.name='Infor'

# 11, 查看 DataFrame的 index, column, values属性：
df05.index    # 一维 RangeIndex对象
df05.columns  # 一维 Index对象
df05.values   # 二维 ndarray数组
# array([['张三', 2001, 'female', '北京', nan],
#        ['李四', 2001, 'female', '上海', nan],
#        ['王五', 2003, 'male', '广州', nan],
#        ['马六', 2002, 'male', '深圳', nan]], dtype=object)


# 12, 索引对象的操作方法：
# pandas 中的索引对象是用于存储轴标签和其他元数据的 （例如轴名称或标签）。
data={
    'name':np.array(['张三','李四','王五','小明']),
    'sex':('female','female','male','male'),
    'year':[2001,2001,2003,2002],
    'city':('北京','上海','广州','深圳')
}
df=DataFrame(data)

# 1) 索引对象
df.index

# 2) 索引对象不可通过被索引的方式更改，强改会报错：
index=df.index     index[1]=0    # 报错
col = df.columns   col[1]='a'    # 报错
# 可通过如下方式修改 DataFrame的索引：
df.index=['a','b','c','d']
df.columns=['c1','c2','c3','c4'] 

# 3）对 DataFrame的行列索引的 name属性赋值/修改：
df.index.name='infor item'
df.columns.name='details'

# 三，pandas 索引操作

# (1)讲解 Series 和 DataFrame 的索引操作的方法
# (2)与 Excel 数据类比，讲解 DataFrame 数据的选取与操作

# 1) 修改行或列的索引标签：
# 更改行索引，可以使用 df.index=[新索引列表],或 df.rename(index={'c':'cc'}, inplace = True)
# 更改列索引，可以使用 df.rename(columns={'COMPANY':'公司'}, inplace = True) 

# 2) 重新索引,引入新的索引，se.reindex([]); df.reindex(index=[],columns=[])：
# 用来引入新的行或列，不是用来按位置更改索引的名称，因为引入新的索引名称，会带来 NaN行或 NaN列.

# 2-1）Series 重新索引： se_obj.reindex(新索引列表[,method='ffill'])  
# 返回一个新的 Series对象，不改变原来的 Series.
# method 缺省时，新引入的索引对应的元素值为 NaN,
# method='ffill' 指元素值与前面相同（向后填充），
# method='bfill' 指元素值与后面相同（向前填充）。

# 没有使用原来的索引f及对应数据,新引入了索引 m,e及NaN :
s_obj=Series([1,2,3,4],index=['a','c','d','f'])
s_obj2=s_obj.reindex(['a','c','m','d','e'])   
s_obj2

a    1.0
c    2.0
m    NaN
d    3.0
e    NaN
dtype: float64

# method='ffill',d的值填充e,f的值填充m  （字母顺序）
s_obj=Series([1,2,3,4],index=['a','c','d','f'])
s_obj3=s_obj.reindex(['a','c','m','d','e'],method='ffill')   
s_obj3

a    1
c    2
m    4
d    3
e    3
dtype: int64
    
# method='bfill',f的值填充e,NaN填充m    （字母顺序）
s_obj4=s_obj.reindex(['a','c','m','d','e'],method='bfill')   
s_obj4    
a    1.0
c    2.0
m    NaN
d    3.0
e    4.0
dtype: float64
    

# 2-2）DataFrame 重新索引：返回新的 DataFrame, 不改变原有 DataFrame
df=DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['name','id','sex'])
df2=df.reindex(index=['a','b','c','d'],fill_value=0)   # 重新索引，引入一个新的行
df3=df.reindex(columns=['name','id','gender','job'],fill_value=0)   # 重新指定列索引要使用 columns关键字
# 当 fill_value参数缺省或 fill_value=None时，引入的新行或列对应的元素值是 NaN


# 3, 替换默认索引 df.set_index(要使用的某个列的标签)：（针对 DataFrame）     返回新的 DataFrame, 不改变原来的 DataFrame
df=df.set_index('name')  # 使用 name 这列来替代默认行索引，'name'变成了行索引的index.name 属性值。


# 4, 更新默认索引 df2.reset_index([drop=True])  # drop是可选参数
df=df2.reset_index()            # 恢复 df之前的样子
df=df2.reset_index(drop=True)   # name列没有了，行索引变为 从0开始的数字


# 5, 数据的索引和选取:
# 5-1）Series 的数据选取：
# 行号索引：      S[n]         # 得到元素
# 行标签索引：    S['a']       # 得到元素
# 行号切片索引    S[n1:n2]      注意，与 Python列表相同：    含左不含右
# 行标签切片索引  S['i1':'in']  注意，与 Python列表不同之处： 含左也含右！！！
# 布尔索引        S[S==2]
S=Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])
S[2]    # 3
S['b']  # 2
S[0:3]  
# a    1
# b    2
# c    3
# dtype: int64
S['a':'c']
# a    1
# b    2
# c    3
# dtype: int64
S[S>2]
# c    3
# d    4
# e    5
# f    6
# dtype: int64

# 对选取元素或切片的值的更改，会影响到原来的 Series或 DataFrame。
S[2]=6   # S['a':'c']=0 
S

####################################################### 重点 loc,iloc############################################################


# 5-2）DataFrame 的数据选取：
data={
    'name':np.array(['张三','李四','王五','小明']),
    'sex':('female','female','male','male'),
    'year':[2001,2000,2003,2002],
    'city':pd.Series(['北京','上海','广州','深圳'])
}
df=DataFrame(data)
df2=df.set_index('name')
df2

# DataFrame 行列 选取总结：

# 1）对列的索引直接使用df.[列索引名]或df.列索引名
# 2）对行的索引使用df.loc[行索引名] 或 df.iloc[列索引位置]
# df2['王五']            # 报错  
# df2[1]                 # 报错
# df2.[['张三','王五']]  # 报错
# df2.[[1,3]]            # 报错

# 为了防止弄混，DataFrame选取多行时，一律使用 loc和 iloc：（当使用切片时，不使用 loc iloc也是允许的）

# 获取单个元素：
df.loc['王五',2] 
df.iloc[2,2] 

# 单行：
df.loc['王五']   
df.iloc[1]  

# 多行：
df.iloc[[1,3]] 
df.iloc[0:2]   # 这样也行： df[0:2]  但不推荐
df.loc[df['sex']=='female']   # df[df['sex']=='female']  虽然也可以，但不推荐
df.loc[['张三','王五']]  


# 单列：
df.year     # 按属性选取
df['year']  # 按列索引标签选取
df.loc[:,'year'] 
df.iloc[:,2] 

# 多列：(不可使用列索引名进行切片)
# df[['year','name']]  不推荐
df.loc[:,['year','name']] 
df.iloc[:,[1,3] 
df.iloc[:,1:3] 

# 选取行列子集：
df.loc[df.index[0:2], ['name','city']]    # df.index[0:2]  RangeIndex(start=0, stop=2, step=1)
df.loc[df.index[[0,2]], ['name','city']]
df.iloc[df.index[[0,2]], [0,2]]
df=df.loc[df['status']!="Cancelled",['CNUM','status',"Tax"]]  # 选取 status列中的值不是cancelled的'CNUM','status',"Tax"三列数据。类似excel里的筛选。

# 布尔选择
# 与数组布尔型索引相似：！=  ~  & |
df[df['sex']=='female']   # 返回符合条件的行列子集   df['sex']=='female' 布尔型 Series
df[df['sex']=='female' & df['year']==2001] # 必须使用括号
df[(df['sex']=='female') & ~(df['year']==2001)] 
df[(df['sex']=='female') & (df['year']!=2001)] 
df[(df['sex']=='female') | (df['year']==2002)] 

# 使用 loc/iloc 和布尔索引确定 符合条件的元素
df.loc[df['sex']=='female','female'] ='女'    # 这样 sex为 female对应的的sex列的值变为 f
iris_df.loc[iris_df['class'] == 'versicolor', 'class'] = 'Iris-versicolor'

# 对索引出来的数据进行修改，会影响到原来的数据结构
df[df['sex']=='female'] ='f'      # 这样 sex为 female的整行数据都会变为 f
df.loc[df['sex']=='female','female'] ='f'  # 这样 sex为 female对应的的sex列的值变为 f
df['year'] = 2010

# 要想索引出来的数据独立使用，不影响原来数据结构，就要使用 .copy()
df2=df[df['sex']=='female'].copy()
df2.year=2030


# 6, DataFrame的增，删，改，查（即索引）
# 【 不会改变原来的 DataFrame,返回一个新的 DataFrame】

# 6-1）查  即上面的   5, 数据的索引和选取:
        
# 6-2)增
# 6-2-1）对行的增加： df.append(new_data,ignore_index=True)    增加一行数据
import numpy as np
from pandas import DataFrame,Series
import pandas as pd
data={
    'name':np.array(['张三','李四','王五','小明']),
    'sex':('female','female','male','male'),
    'year':[2001,2000,2003,2002],
    'city':pd.Series(['北京','上海','广州','深圳'])
}
df=DataFrame(data)
new_data={
    'name':"Tom",
    'sex':'male',
    'year':2007,
    'city':'南京'
}
df2=df.append(new_data,ignore_index=True)   # 返回一个新的 DataFrame, 不影响原来的。ignore_index=True参数是必须要有的
df2
# 除了使用 append()还可以参见  二 DataFrame  6-2,给行赋值和增加新的行
# 6-2-2) 对列的增加： 对列的增加删除和修改见 ： 二 DataFrame  6-1,给列赋值和增加新的列

# 6-3)删
# 删除行：new_df=df.drop(2,axis=0)       或 # 删除行：new_df=df.drop('i3',axis=0)  其中 axis=0可以缺省
# 删除列：new_df=df.drop('city',axis=1)  
# 删除原数据的列： del df['city'](会影响原数据)

# 6-4)改  
# 这里的修改是指 对行列索引标签的修改，通过 df.rename()函数，可完成由于某些原因导致的标签录入错误的问题：
# 当参数inplace=True时，会原地修改，当inplace=False或缺省时，不会影响原数据，返回一个新的数据。
new_df4=new_df3.rename(index={'王五':'王老五','小明':'马六'},columns={'sex':'gender'})
new_df3.rename(index={'王五':'王老五','小明':'马六'},columns={'sex':'gender'},inplace=True) # 可在原数据上进行修改

# 四，pandas 算术运算 

# 参与运算的 各个 Series 的size大小任意。
# 参与运算的 各个 DataFrame 的行数必须相同。

# 1, Series 算术运算
# 有共同索引的元素才会进行算术运算，如果没有，则引入 NaN --对齐操作
from pandas import Series,DataFrame
S1=Series([2.1,5,-3,0.2,0.3],index=['a','c','d','f','g'])
S2=Series([3.5,1.5,-2,0.5],index=['a','b','d','e'])  # 共同索引为 'a','d'
S1+S2
# S1.add(S2,fill_value=0)  # 缺失值 按 0 计算  

# 2, DataFrame 算术运算
# 对于 DataFrame数据，对齐操作会同时发生在行和列上
df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])
df2=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','coco'],columns=['a','b','d'])
df1+df2  # 运算返回的结果包含了参与运算的 df的所有的列。  行和列都符合才可以计算。
# df1.add(df2,fill_value=0)   # 行或列只要有一个符合，就可以计算,缺失值按 0计算，行和列都不符合才是 NaN

# 3, DataFrame 和 Series的 算术运算：
# 要求 Series的【行索引】和 DataFrame的【列索引】要一致。
S1=Series([2,3,4],index=['a','b','c'])
df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])
df1+S1 # df的 a列+2 b列+3，c列+4

df1=DataFrame(np.arange(9).reshape(3,3),index=['apple','banana','tea'],columns=['a','b','c'])
s1=df1.loc['apple']  # 取 DtaFrame的单行，这样得到的 Series对象的索引为 DataFrame的列索引
df1+s1

# 五, 函数应用与映射

# 定义函数或 Lambda表达式，然后应用到 pandas数据中对数据进行较为复杂的函数运算：
# 有三种使用自定义函数的datafrom方法： 参数 f 为自定义函数,也可以是lambda表达式
# 1, se.map(f) 函数              将函数套用在每个 Series 元素上
# 2, df.aplly(f,axis=1)函数      将函数套用在 DataFrame的行与列上,若 axis缺省，则默认axis=0
# 3, df.applymap(f)函数          将函数套用在 DataFrame的每个元素上

# 注意，1) lambda 表达式里如果使用判断表达式，if和 else必须要成对出现！、
#       2) 上面几个映射函数，都不改变原来数据结构，返回新的数据结构。

# se.map(f)示例：
data={
    'fruit':['apple','orange','grape','banana'],
    'price':['25元','42元','35元','15元']
}
df=DataFrame(data)
df2=df1.copy()

def removeyuan(x):
    return x.split('元')[0]  # 取‘25元’中的‘25’

df['price']=df['price'].map(removeyuan)  # df['price'] 是序列
df1['price']=df1['price'].map(lambda x:x.split('元')[0]) 

# df.aplly(f,axis=1)示例：
df2=DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['linux','win','mac'])
f=lambda x:x.max()-x.min()  # 放在apply()里 x在这里代表 行或列
df2.apply(f)  

# df.applymap(f)示例： 
df2.applymap(lambda x:'%.2f'%x)  # 保留小数点两位