python pandas的基本使用及基本操作小例子！
一、生成数据表
1.首先导入pandas库，一般会用到numpy库，所以先导入备用！
import numpy as np
import pandas as pd
2.导入CS或者xlsx文件：
fandango=pd.read_csv(“自己的路径及文件”，header=1)
fandango=pd.DataFrame(pd.read_exce(“name.xlsx”))
3用pandas创建数据表：
import numpy as np
import pandas as pd
new_pandas=pd.DataFrame({"col1":range(7),"col2":[11,22,33,44,np.nan,55,66],"col3":[4,6,3,7,8,9,7]})
# print("new_pandas",new_pandas)
# print("new_pandas.values",new_pandas.values)
# print("type(new_pandas.values)",type(new_pandas.values))#ndarray
new_pandas["col4"]=np.where(new_pandas["col1"]>3000,"high","low")
# print("new_pandas",new_pandas)
new_pandas["col2"].fillna(new_pandas["col2"].mean())
print("new_pandas[0:2].loc",new_pandas.loc[0:2])
print("new_pandas.iloc[0:2]",new_pandas.iloc[0:2])
二、数据表信息查看
1.维度查看：shape
2.数据表基本信息（维度，列表名称，数据格式，所占空间等）：info（）
3.每一列数据格式：dtypes
4.某一列格式：dtype
5.空值：isnull
6.查看某一列空值：isnill()
7.查看某一列的唯一值：unique
8.查看数据表的值：values
9.查看列名称：columns
10.查看前10行数据。后10行数据
head() tail()
import pandas
food_info=pandas.read_csv("C:/Total-folder/work/AI/machine/data/food_info.csv")
#打印数据类型
# print("type",type(food_info))#三、数据表清洗
1.用数组0填充空值：fillna(value=0)
2.使用列prince的平均值对NAN进行填充：
例：df.[‘prince’]fillna(df.[‘prince’].mean())
3.清除city字段的空格字符：
例：df[‘city’]=df[‘city’].map(str.stript)
4.大小写转换：
例：df[‘city’]=df[‘city’].str.lower()
5.更改数据格式：
例：df[“price”].astype(‘int’)
6.更改列名称：
例：df.rename(colimns={“category”:“category-size”})
7.删除后出现的重复值：
例：df[‘city’].drop_duplicates()
8.删除先出现的重复值：
例：df[‘city’].drop_duplicates(keep=“last”)
9.替换数据：
例：df[‘city’].replace(“sh”,“shanghai”)
import numpy
import pandas
from pandas import Series,DataFrame
# 创建 Series，pandas 自动创建 index
s = pandas.Series([1, 3, 5, numpy.nan, 6, 8])
# print("s",s)
# 删除包含 NaN 的行
# print("s.dropna()",s.dropna())
# # 删除包含 NaN 的列
# print("s.dropna(axis=0)",s.dropna(axis=0))
# # 填充 NaN 为指定的值
print(s.fillna(value='未知'))#dtype: object
# 实例 泰坦尼克号船员的救援
import pandas as pd
import numpy as np
titanic_train=pd.read_csv("C:/Total-folder/work/AI/machine/data/titanic_train.csv")
titanic_train.head()
# 我们值获取不为NAN的那些值
# 获取不带有NAN的数据
new_age=titanic_train["Age"][age_is_null==False]
print("长度",len(new_age))
# 再求平均值
age_avg=sum(new_age)/len(new_age)
print("平均值",age_avg)
# 可以通过一个aip方法获取平均值，他是过滤到NAN的情况
# 页面可通过mean来过滤掉null再计算平均值
print("mean平均值",titanic_train["Age"].mean())
四、数据预处理
1.数据合并
1.1 merge
例：df_inner=pd.merge(df,df,how=‘inner’)#匹配合并
交集：df_left=pd.merge(df,df,how=‘leftr’)
df_left=pd.merge(df,df,how=‘right’)
并集：df_left=pd.merge(df,df,how=‘outer’)
1.2 append result=df1.append(df2)
1.3 join result=left.join(right,on=‘key’)
1.4concat
pd.concat(objs,axis=0,join=“outer”,join_axes=None,ignore_index=False,keys=None,leverls=None,names=None,venify_integrity=False,copy=True)
object：一个序列或系列、综合活面板对象的映射。如果字典中传递，将作为键参数，使用排序的键，除非它传递，在这种情况下的值将会选择（见下文）。
任何没有任何反对将陌陌的被丢弃，除非他们都没有在这种情况下将引发ValueError.
axis:{0,1,…},默认值为0.要链接沿轴。
join:{“neibu ”,“外”},默认“外”。
如何处理其他axis(es)上的索引。联盟内，外的交叉口。
ignore_index:布尔值、默认False。如果为True，则不要串联轴上使用的索引值。由此产生的轴将标记0，…,n-1.
这是有用的如果你串联串联轴没有有意义的索引对象。请注意在串联接中仍然受到尊重的其他轴上的索引值。
join_axes:索引对象的列表。
具体指标，用于其他n-1轴二不是执行内部活外部设置逻辑。
keys:序列默认，默认为无。构建分层索引使用使用的键操作为最外面的级别。如果多个级别获得通过，应包含元祖。
levels：列表的序列，默认为无。具体水平（唯一值）用于构建多重。否则，他们讲退佃钥匙。
names:列表中，默认为无。又粗产生的分层索引中的级的名称。
verify_integrity:布尔值、默认False。j检查是否新的串联的轴包含重复项。
这可以是相对于实际数据串联非常昂贵。
副本：布尔值、默认True。如果为False，请不要，不必要的复制数据。
例子
1：frames=[df1,df2,df3]
result=pd.concat(frames)
2:设置索引列 df_inner.set_index(id)
3.按照特定列的值排序：df_inner.sort_values(by=[“age”])
4.按照索隐裂排序：df_inner.sort_index()
5.如果prince列的值>3000，group列显示high，否则显示low"
df_inner[“group”]=np.where(df_inner[“price”]>3000,“high”,“low”)
6.对复合多个条件的数据进行分列标记：
df_inner.loc[df_inner[“city”]==“beijing”)&[df_inner[“price”]>=4000),“sign”]=1
7.对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列。列名称为category和size :
pd.DataFarm((x.split("-") for x in df_inner[“category”],index=df_inner.index,columns=[“category”,“size”]））
8.讲完成分列后的数据表和原df_inner数据表进行匹配
df_inner=pd.merge(df_inner,split,right_index=True,left_index=True)
五、数据提取 主要用到的三个函数：loc,iloc和ix，
loc函数按照标签值进行提取，iloc按位置进行提取
1、按索引提取单行的数值df_inner.loc[3]
2、按索引提取区域行数值df_inner.iloc[0:5]
3、提取千山个字符，并生成数据表：pd.DataFrame(category.str[:3])
**六、数据筛选 使用与或非三个条件配合>=<对数据进行筛选，并进行技术和求和。
1、与：df_inner.loc[(df_inner.loc[“age”]>25)]&df_inner.loc[“city”]==“beijing”),[“id”,“city”,“age”,“category”,“gender”]]
2、或：
df_inner.loc[(df_inner.loc[“age”]>25)]|df_inner.loc[“city”]==“beijing”),[“id”,“city”,“age”,“category”,“gender”]].sort([“age”])
3、非：
df_inner.loc[(df_inner.loc[“age”]>25)]|df_inner.loc[“city”]！=“beijing”),[“id”,“city”,“age”,“category”,“gender”]]。sort([“id”])
4、对筛选后的数据按city列进行计数：
df_inner.loc[(df_inner.loc[“city”]！=“beijing”),[“id”,“city”,“age”,“category”,“gender”]]。sort([“id”]).city.count()
5、使用query函数筛选：
df_inner.query（“city”==[“beijing”,“shanghai”]）
6、对筛选后的结果按prince进行求个
df_inner.query（“city”==[“beijing”,“shanghai”).price.sum()**
七、数据汇总 主要函数是groupby 和pivote_table
1、对所以的列进行计数汇总：
df_inner.groupby(“city”).count()
2、按照城市对id字段进行计数：
df_inner.groupby(“city”)[“id”].count()
3、对两个字段进行汇总计数：
df_inner.groupby(“city”，“size”)[“id”].count()
4、对city字段进行汇总。并分别计算price的合计和平均值
df_inner.groupby(“city”)[“price”].agg([len,np.sum,np.mean])
八、数据统计
1、简单菜单数据采样
df_inner.sample(n=3)
2、手动设置采样权重
weights=[0,0,0,0,0.5,0.5]
df_inner.sample(n=2,weights=weights)
3、采样后不放回
df_inner.sample(n=6,replace=False)
4、采样后放回
df_inner.sample(n=6,replace=True)
5、数据表描述性统计
df_inner.describe().round(2).T#round函数设置显示小失误，T表示转置
九、数据输出 分享后的数据可以输出为xlsx格式和csv格式
1、写入Excel
df_inner.to_excel(“excel_topython.xlsx”,sheet_name=“bluewhale_cc”)
2、写入到CSV
df_inner.to_csv(“excel_topython.csv”)
相关测试代码：
import pandas
food_info=pandas.read_csv("C:/Total-folder/work/AI/machine/data/food_info.csv")
#打印数据类型
# print("type",type(food_info))#import numpy
import pandas
from pandas import Series,DataFrame
# 创建 Series，pandas 自动创建 index
s = pandas.Series([1, 3, 5, numpy.nan, 6, 8])
# print("s",s)
# 删除包含 NaN 的行
# print("s.dropna()",s.dropna())
# # 删除包含 NaN 的列
# print("s.dropna(axis=0)",s.dropna(axis=0))
# # 填充 NaN 为指定的值
print(s.fillna(value='未知'))#dtype: object
import pandas
# 自动创建 index
my_data = [10, 20, 30]
s = pandas.Series(data=my_data)
print("s1",s)
'''
默认索引值0开始
0 10
1 20
2 30
dtype: int64
'''
# 指定 index
my_index = ['UK', 'US', 'CN']
s = pandas.Series(data=my_data, index=my_index)
print("s2",s)
'''
指定索引值
UK 10
US 20
CN 30
'''
# 根据字典创建 Series
my_dict = {'UK':10, 'US':20, 'CN':30}
s = pandas.Series(data=my_dict)
print("s3",s)
'''
根据字典创建 Series
s3 CN 30
UK 10
US 20
dtype: int64
'''
# 同字典，根据索引访问
print(f"data of index CN is {s['UK']}")
# 自定义一个 DataFrame数据
import numpy as np
import pandas as pd
new_pandas=pd.DataFrame({"col1":range(7),"col2":[11,22,33,44,np.nan,55,66],"col3":[4,6,3,7,8,9,7]})
# print("new_pandas",new_pandas)
# 样本，ndarray数据
# 结构
# print("new_pandas.shape",new_pandas.shape)#(7, 3)
matrix=new_pandas.values
# print("matrix",matrix)#只有样本没有特征
# print("new_pandas.columns",new_pandas.columns)
#['col1', 'col2', 'col3']只有特征 object类型
# print("type(matrix)",type(matrix))#ndarray
# 最基础的获取数据的方法 获取列 行
# 获取某一列的数据
# print("new_pandas[['col1','col2']]",new_pandas[["col1","col2"]])
# 每一列的数据类型是series类型
# print("type(new_pandas[['col1','col2']])",type(new_pandas[["col1","col2"]]))#DataFrame
# print("new_pandas['col1'][0:5]",new_pandas['col1'][0:5])
# 每一列的数据类型是series类型
# print("type(new_pandas['col1'][0])",type(new_pandas['col1'][0]))#int32
# 为nan的填充为0
news=new_pandas.fillna(value=0)
print("news",news)
# 过滤出想要的数据
# 想得到食物的指标中 带有G的指标是数据 过滤到mg的数据
# 先获取到所有的列名
col_names=food_info.columns.tolist()
# print("col_names",col_names)#所有样本的名字
# 对这个列表进行遍历 过滤
gram_colums=[]
for c in col_names:
if c.endswith("(g)"):
gram_colums.append(c)
# print("gram_colums",gram_colums)
# 获取到了带g指标的列表名
# print("food_info[gram_colums].head(3)",food_info[gram_colums].head(3))
food_info[gram_colums]=food_info[gram_colums]*1000
# print("food_info[gram_colums].head(3)",food_info[gram_colums].head(3))
# 对数据进行计算
# 得到指定列处的所有值/1000 相当于对所有数据都进行计算
print("food_info['Iron_(mg)']",food_info['Iron_(mg)'])
print("food_info['Iron_(mg)']/1000",food_info['Iron_(mg)']/1000)
# 对两个列进行组合 首先维度是一样的，会对对用位置进行操作
water_energy=food_info["Water_(g)"]*food_info["Energ_Kcal"]
# print("water_energy",water_energy)
# 可以往dataframe中增加一列
# 首先保证要增加的这一列与现有的数据中的列的竖向量是一致的
# 就是原有的8618条数据 那么新增的一列数据也必须是8616条数据才行
# 例如得到原有这一列的g单位的数据
# iron_grams=food_info["Iron_(mg)"]/1000
# food_info["Iron_(g)"]=iron_grams
# 在打印当前datafram数据的结构就是37列了
# print("food_info.shape",food_info.shape)#(8618, 37)
# 对某些列进行计算，都是对这一列的所有数据进行计算的
weighted_protein=food_info["Protein_(g)"]*2
# print("weighted_protein",weighted_protein)
weighted_fat=-0.75*food_info["Lipid_Tot_(g)"]
# print("weighted_fat",weighted_fat)
initial_rating=weighted_protein+weighted_fat
print("initial_rating",initial_rating)
# 可以取出某一列中所有数据的最大值或者最小值
# print("type(food_info['Sodium_(mg)'][0:9])",type(food_info['Sodium_(mg)'][0:9]))#Series
weighted_proteinmax=food_info['Sodium_(mg)'].max()
print("weighted_proteinmax",weighted_proteinmax)#38758.0
weighted_proteinmin=food_info['Sodium_(mg)'].min()
print("weighted_proteinmin",weighted_proteinmin)#0.0
# 排序的操作
# 默认是声息的排序 inplace为true标识会对当前的food_info有所改变
# ascending 是否按指定列的矩阵升序排序，默认为True 即升序排列
# inplace 是否用排序后的数据集替换原来的数据，默认为False,既不替换
# news=food_info.sort_values("Sodium_(mg)")
# print("news",news)
# print("food_info['Sodium_(mg)']",food_info["Sodium_(mg)"])
# 降序的排列
# food_info.sort_values("Sodium_(mg)",inplace=True,ascending=False)
# print("food_info['Sodium_(mg)']",food_info["Sodium_(mg)"])
# 实例 泰坦尼克号船员的救援
import pandas as pd
import numpy as np
titanic_train=pd.read_csv("C:/Total-folder/work/AI/machine/data/titanic_train.csv")
titanic_train.head()
# 有些列中缺失值的 缺失值在数据中NAN显示的 我们可以把他们找到
age=titanic_train["Age"]
# print("age",age)
# print("age.head(20)",age.head(20))
# 有一个方法 is_null可以找到当前列表中所有为null的是true 不为null的是False
age_is_null=pd.isnull(age)
# print("age_is_null",age_is_null)
# age_is_null也可以把它当成应对的索引放在列表中使用 会使用为true的那些对应的索引
# 可以找到一共有多少个为null的年龄
age_null_true=age[age_is_null]
print(len(age_null_true))
# 如果要做一个平均年龄的计算 如果带有NAN的话就计算不出来了
# sum--求这一列中所有值的lenen是求这一列的总长度
print("平均值",sum(titanic_train["Age"])/len(titanic_train["Age"]))
# 我们值获取不为NAN的那些值
# 获取不带有NAN的数据
new_age=titanic_train["Age"][age_is_null==False]
print("长度",len(new_age))
# 再求平均值
age_avg=sum(new_age)/len(new_age)
print("平均值",age_avg)
# 可以通过一个aip方法获取平均值，他是过滤到NAN的情况
# 页面可通过mean来过滤掉null再计算平均值
print("mean平均值",titanic_train["Age"].mean())
# 获取每一等舱的价格的平均值
# 创建一个船舱等级的列表
passenger_classes=[1,2,3]
# 创建最后存储每一个等级对应票据的平均值
fares_by_class={}
for _class in passenger_classes:
# 得到当前船舱等级对应的列表
pclass_rows=titanic_train[titanic_train["Pclass"]==_class]
# print("pclass_rows",pclass_rows)
# 得到这个等级对应的船票价格
pclass_fares=pclass_rows["Fare"]
# print("pclass_fares船舱的价格",pclass_fares)
fare_class_avg=pclass_fares.mean()
print("船舱等级",_class,"船舱人数",len(pclass_rows),"价格平均值",fare_class_avg)
# 把平均值记录到对应的字典中
fares_by_class[_class]=fare_class_avg
print("船舱对应价格的平均值",fares_by_class)
# 通过透视表可以很清楚的得到列与列之间的关系 默认列与列直接的关系要求平均值
passenger_age=titanic_train.pivot_table(index='Pclass',values="Age")
print("passenger_age",passenger_age)
print("type(passenger_age)",type(passenger_age))#DataFrame
# pivot_table汇总
# values是要进行汇总，统计等运算的列，可以是多个（list格式）；
# index是作为新表的列表，可以是多个（list格式）
# aggfunc是做汇总的统计运算方法，常用的简单运算都可以，
# 也可以是多种方法（每个不同的列指定一种方法），
# 这样就可以免去了多次使用透视表在进行合并的麻烦
passenger_survial=titanic_train.pivot_table(index="Pclass",values="Survived",aggfunc=np.mean)
print("每个等级的平均值",passenger_survial)
# new_titanic_survial=titanic_train.dropna(axis=0,subset=["Age","Sex"])
# print("new_titanic_survial",new_titanic_survial)
# 想定位到具体的一个值上 那么是有行号和列号构成的
# 比如向获取第83条样本的年龄
# row_index_83_age=titanic_train.loc[83,"Age"]
# print("row_index_83_age索引值83的",row_index_83_age)#28.0
# 排序
# 这里面序号还是原来的ID的值
# new_titanic_survial=titanic_train.sort_values("Age",ascending=False)
# print("new_titanic_survial",new_titanic_survial)
# 如果想序号也按照排序来执行了 放弃原来序号的排序了
# titanic_reindexed=new_titanic_survial.reset_index(drop=True)
# print("titanic_reindexed",titanic_reindexed)
# 可以使用自定义的函数 来实现功能
# 例如想获取第100条样本的数据
# 可以使用这种方法来执行
# print("titanic_reindexed.loc[99]",titanic_reindexed.loc[99])
# 也可以使用自定义函数来执行
def hundredth_row(colum):
hundredth_item=colum.loc[99]
return hundredth_item
titanic_index_100_row=titanic_train.apply(hundredth_row)
print("titanic_index_100_row",titanic_index_100_row)
# 计算每一列包含缺失值的自定义方法的例子
def null_count(column):
column_null=pd.isnull(column)
# print("column_null",column_null_count)
null=column[column_null]
# print("len(null)",len(null))
return len(null)
column_null_count=titanic_train.apply(null_count)
print("column_null_count",column_null_count)
# 对列表的数据可以进行处理 比方说等级123替换成first,second,third
def witch_class(row):
# print("row",row)
pclass=row["Pclass"]
# print("pclass",pclass)
if pd.isnull(pclass):
return "UnKnow"
elif pclass==1:
return "first"
elif pclass==2:
return "second"
elif pclass==3:
return "third"
classes=titanic_train.apply(witch_class,axis=1)
print("classes",classes)#Length: 891, dtype: object
# series结构
# DataFrame(是有多个series结构的对象构成 也就是一个个矩阵构成)
# 读取cvs文件
fandango=pd.read_csv("C:/Total-folder/work/AI/machine/data/fandango_score_comparison.csv")
series_film=fandango["FILM"]
# print("series_film",series_film)
# print("fandango",fandango)
# print("type(fandango)",type(fandango))#DataFrame
print("series_film[0:5]",series_film[0:5])
series_rot=fandango["RottenTomatoes"]
# print("series_rot[0:5]",series_rot[0:5])
print("type(series_rot)",type(series_rot))#Series
from pandas import Series
# pandas dataframe 是由series构成 而series是由ndarray构成
film_names=series_film.values
# 得到上面的媒体得分
# print("film_names",film_names)
# print("film_names[0:3]前三个电影名字",film_names[0:3])
rt_scores=series_rot.values
# print("rt_scores上面电影的第一列得分",rt_scores[0:5])
# 自定义一个series对象 索引可以是一个字符串
series_custom=Series(rt_scores,index=film_names)
# print("series_custom.head(3)",series_custom.head(3))
print("series_custom[0:5]",series_custom[0:5])
# 获取指定影片的媒体得分 可以通过下面的方法来获取
news=series_custom[["Avengers: Age of Ultron (2015)","Cinderella (2015)"]]
print("news",news)
# 可以对series进行操作
# 比方说排序 可以按照索引排序也可以值排序 按照电影的名称进行排序
# ascending:布尔值,True则升序，如果by=["列名1","列名2"]，
# 则该参数可是是[True,False],即第一段升序，第二段降序，默认是升序
# inplace:布尔值，是否用排序后的数据框替换现有的数据框。默认是false 不替换
# series_custom.sort_index(inplace=True,ascending=False)
# print("series_custom按照column排序",series_custom)
# 得分排序
series_custom.sort_values(inplace=True,ascending=False)
print("series_custom按照分数排序",series_custom)
# 也可以对两个series进行相加 前提两个维度相同的series可以相加
add_series=np.add(series_custom,series_custom)
# print("add_series",add_series)
print("add_series.head(3)",add_series.head(3))
print(type(add_series))#Series
# print("正弦",np.sin(series_custom))
# print("最大值",np.max(series_custom))
# 进项判断查找买组条件的数据
series_than_50=series_custom[series_custom>50]
print("大于50",series_than_50)
# 定义两个series对象 求平均值
# rt_1表示RottenTomatoes 这个每天对所以电影的评分
rt_1=Series(fandango["RottenTomatoes"].values,index=fandango["FILM"])
# print("rt_1",rt_1)
# rt_2 表示 Metacritic 这个每天对所以电影的评分
rt_2=Series(fandango["Metacritic"].values,index=fandango["FILM"])
# print("rt_2",rt_2)
rt_avg=(rt_1+rt_2)/2
print("rt_avg",rt_avg)
import numpy as np
import pandas as pd
new_pandas=pd.DataFrame({"col1":range(7),"col2":[11,22,33,44,np.nan,55,66],"col3":[4,6,3,7,8,9,7]})
# print("new_pandas",new_pandas)
# print("new_pandas.values",new_pandas.values)
# print("type(new_pandas.values)",type(new_pandas.values))#ndarray
new_pandas["col4"]=np.where(new_pandas["col1"]>3000,"high","low")
# print("new_pandas",new_pandas)
new_pandas["col2"].fillna(new_pandas["col2"].mean())
print("new_pandas[0:2].loc",new_pandas.loc[0:2])
print("new_pandas.iloc[0:2]",new_pandas.iloc[0:2])