pandas超级详细的教程

pandas

创建文件

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。

DataFrame既有行索引也有列索引，它可以被看做由series组成的字典（共用同一个索引）

set_index( ) 将 DataFrame 中的列转化为行索引。默认的，当列变成行索引之后，原来的列就没了，但是可以通过设置drop来保留原来的列。

to_excel()函数用于将DataFrame导出到excel文件。

import pandas as pd
df = pd.DataFrame({'ID':[1,2,3],'Name':['Tim','Victor','Nick']})
df = df.set_index('ID')
df.to_excel('E:/pandas/output.xlsx')
print('Done!')

读取文件

read_excel函数用来读取pandas的数据

shape(a,b)：查看矩阵或者数组的维数,第一维表示长度为a，第二维表示长度维b。

columns参数用于获取dataframe各列的表头名，也可以用于修改列名。

head函数默认是取出前5行数据，如果想要输出指定数据，可以在函数中指定数据。

tail方法默认显示数据集的后5行，也可以指定数据。

import pandas as pd
people = pd.read_excel('E:/pandas/output.xlsx')
print(people.shape)
print(people.columns)
print(people.head())
print(people.tail())

header：设置表头，当第一行为字符，则第一行数据默认为标题；当第一行与其他数据类型相同时，也会把第一行当作表头，所以无表头时应设置header=None，当有表头时，设置header=0，则第一行数据为表头。若设置header=1，则第二行数据默认为表头。

import pandas as pd
people =
pd.read_excel('E:/pandas/output.xlsx',header=1)
print(people.columns)

inplace参数为True时，不创建新的对象，直接对原始对象进行修改；为False时对数据进行修改，创建并返回新的对象承载其修改结果。

peole.set_index('ID',inplace=True)

index_col用来指定表格的索引值。如果文件格式不正确，可以考虑使用index_col=false强制pandas不适用第一列作为索引。在使用None的时候，会自动将第一列作为索引，并额外添加一列。所以大多我们会使用index_col=0,直接将第一列作为索引，不额外添加列。如果知道某个数据为某一列可以直接指定。

import pandas as pd
df = pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
df.to_excel('E:/pandas/output2.xlsx')
print('Done!')

行，列，单元格

keys()函数用于返回pandas对象的信息轴，返回列表中的键。

values()函数用于返回对应的二维NumPy值数组，返回列表中的值。

index()函数用于查询数据

series是一组带标签数组，即由一组数据和与之相关的标签组成的一维数据对象。与list以及numpy中array相似，但list中元素可以为不同数据类型，而另外两者只能为相同数据类型。series类型包括(index,values)两部分。

import pandas as pd
d = {'x':100,'y':200,'z':300}
print(d.keys())
print(d.values())
print(d['x'])
print(pd.Serise(d))
print(pd.Serise(d).index)

import pandas as pd
s1 = pd.Series([100,200,300],index=['x','y','z'])
print(s1)

import pandas as pd
s1 = pd.Series([1,2,3],index=[1,2,3],name='A')
s2 = pd.Series([10,20,30],index=[1,2,3],name='B')
s3 = pd.Series([100,200,300],index=[1,2,3],name='C')
df = pd.DareFrame({s1.name:s1,s2.name:s2,s3.name:s3})
print(df)
#name是每一列的名称，index每一行的名称。
#要以字典的方式输出，如果以列表方式输出则名称会出现混乱。

数字区域读取，填充数字

skiprows=3跳过前三行。usecols读取指定的列

at可以给某行某列赋值

dtype：设置数组元素类型

datetime.date - 表示日期的类，常用属性：year, month, day

datetime.timedelta - 表示时间间隔，即两个时间点（date，time，datetime）之间的长度

import pandas as pd
books = pd.read_excel('E:/pandas/output.xlsx',skiprows=3,usecols='C:F',index_col=None)
print(books)

import pandas as pd
books=pd.read_excel('E:/pandas/output.xlsx',index_col=None)
books['ID'].at[0]=100
print(books['ID'])

import pandas as pd
from datetime import date,timedelta
books=pd.read_excel('E:/pandas/output.xlsx',skiprows=3,usecols='C:F',index_col=None,dtype={'ID':str,'inStore':str,'Date':str})
start = date(2018,1,1)
for i in books.index:
    books['ID'].at[i]=i+1
    books['inStore'].at[i]='Yes'if i%2 ==0 else 'No'
    #如果i%2==0则输出yes，否则输出no
    books['Date'].at[i] = start
print(books)

填充日期序列

timedelta在此处用于添加天数

date在此也用于添加年月日

books['Date'].at[i]=start + timedelta(days=i)
books['Date'].at[i]=date(start.year + i,start.month,start.day)

#at方法找值
books.at[i,'ID'] = i+1
books.at[i,'InStore']='Yes'if i%2 == 0 else 'No'

函数填充，计算列

apply()当一个函数的参数存在于一个元组或者一个字典中时，用来间接的调用这个函数，并肩元组或者字典中的参数按照顺序传递给参数。

import pandas as pd
books = pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
books['price']=books['listprice']*books['discount']
#price这列的值等于listprice这列的值乘于discount这列的值
print(books)

#如果想要计算某一段的值，可以使用for循环
for i in range(5,16):
    books['price'].at[i]=books['listprice'].at[i]*books['discount'].at[i]
print(books)

#为一列数据加2，也可以乘某个值等等
books['listprice'] = books['listprice']+2


import pandas as pd
def add1(x):
    return x+2
books = pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
book['listprice']=books['listprice'].apply(add1)

#也可以使用lambda表达式
books['listprice']=books['listprice'].apply(lambda x:x+2)

排序，多重排序

sort_values函数是对列进行排序，by=[‘a’,'b]中是根据a排序再根据b排序。ascending=Ture是从小到大，=False是从大到小。

import pandas as pd
products = pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
products.sort_values(by=['Worthy','price'],inplace=Ture,ascending=[True,False])
#这里ascending中的两个数据分别对应前面by中的两个数据
print(products)

数据筛选和过滤

loc函数的作用是按标签取数据，用[]而不是元括号。

python中如果想要把一条数据分开要用空格+\。

import pandas as pd
def age1(a):
    return 18<=a<30
def level2(s):
    return 85<=s<=100
students=pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
students=students.loc[students.Age.apply(age1)].loc[students.Score.apply(level2)]
print(students)

#也可以使用lambda表达式表示
students=students.loc[student.Age.apply(lambda a:18<=a<30)].loc[students.Score.apply(lambda s:85<=s<=100)]
print(students)

柱状图

plt.tight_layout()把图表变得紧凑

plot.bar()用于画柱状图

import pandas as pd
import matplotlib.pyplot as plt
students = pd.read_excel('E:/pandas/pad/biaoge/List.xlsx')
students.sort_values(by='Number',inplace='True',ascending=False)
print(students)
students.plot.bar(x='field',y='number',color='orange',title='international')
plt.tight_layout()
plt.show()

xticks()函数设置X轴方法–刻度、标签

xlabel()函数为x轴添加标签

ylabel()函数为y轴添加标签

做图标时y轴必须是值，不能是字符串等类型否则会报错

import pandas as pd
import matplotlib.pyplot as plt
students = pd.read_excel('E:/pandas/pad/biaoge/List.xlsx')
students.sort_values(by='Number',inplace=True,ascending=False)
print(students)
plt.xlabel('Fleld')
plt.ylabel('Number')
plt.title('international',fontsize=16)
plt.tight_layout()
plt.show()

分组柱图，深度优化

fontsize:设置轴刻度的字体大小

fontweight：设置字体粗细

plt.gca():获取当前子图，以实现绘图

plt.gcf()：获取当前图表，以实现绘图

rotation：旋转角度

set_xticklabels：继续设置x轴

ha：水平对齐(在下列例子中字体和x轴上的每个柱形图对齐)

subplots_adjust：子图形的调整

left：左边留出区域多少

bottom：下边留出区域多少

import pandas as pd
import matplotlib.pyplot as plt
students = pd.read_excel('E:/pandas/pad/Stu_data/010/Students.xlsx')
students.sort_values(by='2017',inplace=True,ascending=False)
print(students)
students.plot.bar(x='Field',y=['2016','2017'],color=['orange','red'])
plt.title('international',fontsize=16,fontweight='bold')
plt.xlabel('Field',fontweight='bold')
plt.ylabel('Number',fontweight='bold')
ax = plt.gca()
ax.set_xticklabels(students['Field'],rotation=45,ha='right')
f = plt.gcf()
f.subplots_adjust(left=0.2,bottom=0.42)
plt.tight_layout()
plt.show()

叠加柱状图，水平柱状图

stacked:把柱形图叠加起来

plt.tight_layout()把图形变得紧凑，比如x轴上的标签没有完全显示，可以使用它变得紧凑一些。

plot.barh:把竖着的柱状图变成水平的，把下面plot.bar换成plot.barh就可以了。

import pandas as pd
import matplotlib.pyplot as plt
users=pd.read_excel('E:/pandas/pad/biaoge/Users.xlsx')
#创建一个新的列total它的数值等于后面三个相加
users['total']=users['Oct']+users['Nov']+users['dec']
users.sort_values(by='total',inplace=True,ascending=False)
print(users)
users.plot.bar(x='Name',y=['oct','nov','dec'],stacked=True,title='user behavior')
plt.show()

饼图

index_col在这里作为饼图的数据名字

startangle起始点的位置

import pandas as pd
import matplotlib.pyplot as plt
students=pd.read_excel('E:/pandas/pad/Stu_data/012/Students.xlsx')
print(students)
#下面表示只对Scores那一列画图，ascending=True表示按顺时针排序
students['2017'].sort_values(ascending=True).plot.pie(fontsize=8,startangle=-270)
plt.title('Source of international',fontsize=16,fontweight='bold')
plt.ylabel('2017',fontsize=12,fontweight='bold')
plt.show()

折线趋势图，叠加区域图

用.plot直接可以绘制折线图加上.area是区域叠加

import pandas as pd
import matplotlib.pyplot as plt
weeks = pd.read_excel('E:/pandas/pad/Stu_data/013/Orders.xlsx')
print(weeks)
print(weeks.columns)#输出列索引，列名称。
weeks.plot.area(y=['Accessories','Bikes','clothing','components'])
plt.title('sales weekly trend',fontsize=16,fontweight='bold')
plt.ylabel('total',fontsize=12,fontweight='bold')
#加上weeks.index可以为x轴设置一个精确的刻度。
plt.xticks(weeks.index,fontsize=8)
plt.show()

散点图

用plot.scatter可以画出散点图

import pandas as pd
import matplotlib.pyplot as plt
pd.options.display.max_columns = 777#显示所有列(有的时候数据较多会省略)
homes = pd.read_excel('E:/pandas/pad/biaoge/home_data.xlsx')
print(homes.head())
homes.plot.scatter(x='bedrooms',y='price')
plt.show()

直方图

bins表示图中有几个条形图

range中的数据代表直方图中的条形图在x轴上显示的数据是多少(具体数字)

import pandas as pd
import matplotlib.pyplot as plt
pd.options.display.max_columns = 777#显示所有列(有的时候数据较多会省略)
homes = pd.read_excel('E:/pandas/output.xlsx')
print(homes.head())
#画出直方图用plot.hist(),sqft_linving是一个列表名称
homes.sqft_living.plot.hist(bins=100)
plt.xticks(range(0,max(homes.sqft_living),500),fontsize=8,rotation=90)
plt.show()

密度图

用plot.kde()创建密度图

import pandas as pd
import matplotlib.pyplot as plt
pd.options.display.max_columns = 777#显示所有列(有的时候数据较多会省略)
homes = pd.read_excel('E:/pandas/pad/biaoge/home_data.xlsx')
print(homes.head())
homes.sqlt_living.plot.kde()
plt.xticks(range(0,max(homes.sqft_living),500),fontsize=8,rotation=90)
plt.show()

corr()方法可以进行相关性分析

import pandas as pd
import matplotlib.pyplot as plt
pd.options.display.max_columns = 777#显示所有列(有的时候数据较多会省略)
homes = pd.read_excel('E:/pandas/output.xlsx')
print(homes.corr())

多表联合

left_on:左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。

right_on:右侧DataFrame中的列或索引级别用作键。可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。

import pandas as pd
#sheet_name就是获取哪张数据表，比如sheet1，sheet2等等
students = pd.read_excel('E:/pandas/pad/Stu_data/016/Student_Score.xlsx',sheet_name='Students')
scores = pd.read_excel('E:/pandas/pad/Stu_data/016/Student_Score.xlsx',sheet_name='Scores')
#merge是pandas中用来合并数据的函数，on表示按照那个特征来找相同的字段，
#比如两个表中都有城市，并且城市里面有相同的元素，就可以按照这些相同的元素拼接
#how是拼接方式，=outer是外置，相当于两个表求并集，=right是右置，合并后按照最右边不为空的样本显示
#=left是左置，合并后按照最左边不为空的样本显示，=inner只显示匹配到的字段的样本
#fillna()函数用于填充缺失的值，或者指定为每个索引或列使用哪个字典的值。
table = students.merge(scores,how='left',on='ID').fillna(0)
#scp是一个列名称,astype()用来转换为指定的类型
table.Score = table.Score.astype(int)
print(table)

如果将某列设置成了index_col可以将merge换成join，因为merge可能会报错。

数据检验，轴的概念

\t它的含义是一个字符，叫做制表符。它的作用是对齐表格数据的各列。

axis=0指的是逐行，axis=1指的是逐列。

import pandas as pd
def score_validation(row):
    if not 0<=row.Score<=100:
        print(f'#{row.ID}\t student{row.Name}has an invalid socre {row.Score}.')
students = pd.read_excel(E:/pandas/pad/Stu_data/017/Student.xlsx')
students.apply(score_validation,axis=1)

把一列数据分割成两列

str.split()分割函数

expend函数等于True时，会把切割出来的内容当作一列，如果不需要pandas为你分列，将expend=False就行。

import pandas as pd
employees = pd.read_excel('E/pandas/output.xlsx')
#将Full这列以形式分隔
df=employees['Full'].str.split(expend=True)
#将列名为0变成列名为First
employees['First']=df[0]
#将Last这列中的字母全变成大写
employees['Last']=df[1].str.upper()
print(employees)

求和，求平均，统计导引

找子集要用两个方括号

ignore_index = True并不意味忽略index然后连接，而是指连接后再重新赋值index(len(index))。从上面可以看出如果两个df有重叠的索引还是可以自动合并的。

ignore_index = False是默认值

import pandas as pd
students=pd.read_excel('E:/pandas/output.xlsx',index_col='ID')
tmp=students[['test1','test2','test3']]
#为求出的和的那一列和平均值的那一列附上名字
students['Total']=tmp.sum(axis=1)
students['Average']=tmp.mean(axis=1)
#计算所有行相加的平均值
cal=studnets[['test1','test2','test3','Total','Average']].mean()
#为Name这列的最后一行附加一个名字
cal['Name']='Summary'
students=students.append(cal,ignore_index=True)
print(students)

定位，消除重复数据

drop_duplicates：消除重复数据

subset：指定要消除哪一列

keep：当等于first时，遇到重复数据保留前面的，当等于last时，遇到重复数据保留后面的。

import pandas as pd
students = pd.read_excel('E:/pandas/output.xlsx')
students.drop_duplicates(subset='Name',inplace=True,keep='first')

any()用于检验是否有重复数据，有的话显示为True,没有的话显示为False。

iloc()可以截取矩阵，获取部分矩阵元素、行和列。

import pandas as pd
students = pd.read_excel('E:/pandas/output.xlsx')
dupe = students.duplicated(subset='Name')
print(dupe)#找出重复数据
print(dupe.any())
dupe=dupe[dupe == True]#可以显示出只有True的数据
print(students.iloc[dupe.index])

旋转数据表

transpose()函数用于旋转数据表

import pandas as pd
pd.options.display.max_columns=999#用于显示出所有列
videos = pd.read_excel('E:/pandas/output.xlsx')
table = videos.transpose()
print(table)

读取csv，tsv，txt文件中的数据

相同点： csv、tsv和txt都属于文本文件。

不同点：csv和tsv文件的字段间分别由逗号和tab键隔开，而txt文件则没有明确要求，可使用逗号/制表符/空格等 多种不同的符号。

#csv,tsv,txt都用csv来读取
import pandas as pd
student1 = pd.read_csv('E:/pandas/output.csv',index_col='ID')
print(student1)
studnet2 = pd.read_csv('E:/pandas/output.tsv',sep='\t',index_col='ID')
print(student2)
studnet3 =
pd.read_csv('E:/pandas/output.txt',sep='|',index_col='ID')
print(studnet3)

透视表，分组，聚合

Datetimeindex()方法将一组数据转换为时间戳索引，.year代表按年显示

pivot_table()提供一个数据透视表，index是通过将某列设置为索引查看结果，values可以显示出主要的列，aggfunc可以包含很多函数，通过np.sum计算数的总和，columns可以定义一个或多个列。

import pandas as pd
import numpy as np
pd.options.display.max_columns = 999
orders = pd.read_excel('E:/pandas/output.xlsx')
orders['Year']=pd.Datetimeindex(orders['Date']).year
pt1 = orders.pivot_table(index='Category',columns='Year',values='Total',aggfunc=np.sum)
print(pt1)

groupby函数主要的作用是进行数据的分组以及分组后的组内运算。

import pandas as pd
import numpy as np
pd.options.display.max_columns = 999
orders = pd.read_excel('E:/pandas/output.xlsx')
orders['Year']=pd.DatetimeIndex(orders['Date']).year
groups = orders.groupby(['Category','Year'])
s = groups['Total'].sum()
c = groups['ID'].count()
pt2 = pd.DataFrame({'Sum':s,'Count':c})
print(pt2)

线性回归，数据预测

计算线性回归，其中slope和intercept分别为计算所得的拟合直线的斜率和截距。linregress(x轴，y轴)

import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import linregress
sales = pd.read_excel('E:/pandas/pad/biaoge/Sales.xlsx')
print(Sales)
slope,intercept,r,p,std_err = linregress(sales.index,sales.Revenue)
#线性回归方程
exp = sales.index * slope + intercept
print(slope*35+intercept)
#画出线性图
plt.scatter(sales.index,sales.Revenue)
plt.plot(sales.index,exp,color='orange')
plt.title(f"y={slope}*x+{intercept}")
plt.xticks(sales.index,sales.Month,rotation=90)
plt.tight_layout()
plt.show()

条件格式

applymap:将格式无条件的加入进去。

import pandas as pd
def low_score_red(s):
    color = 'red' if s<60 else 'black'
    return f'color:{color}'
def highest_score_green(col):
    return ['background-color:line' if s==col.max() else 'background-color' for s in col]
students = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx')
students.style.applymap(low_score_red,subset=['Test_1','Test_2','Test_3']).qpply(highest_score_green,subset=['Test_1','Test_2','Test_3'])

import pandas as pd
import seaborn as sns
#color_map是变量，light_palette调色板函数,as_cmap为True值，则反转混合的方向。
color_map = sns.light_palette('green',as_cmap=True)
students = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx')
#style.background_gradient根据每列中的数据在渐变中为背景着色。
Students.style.background_gradient(color_map,subset=['Test_1','Test_2','Test_3'])

import pandas as pd
students = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',index_col='ID')
#下面代码是以柱形条形式填充
Students.style.bar(color='orange',subset=['Test_1','Test_2','Test_3'])

行操作集锦

reset_index()重置索引在获得新的index，原来的index变成数据列，保留下来。不想保留原来的index，使用参数 drop=True，默认 False。

Series：创造一个serise数据。

sheet_name：用来设置读取哪个表中数据。

import pandas as pd
page_001 = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',sheet_name='Page_001')
page_002 = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',sheet_name='Page_002')
students = page_001.append(page_002).reset_index(drop=True)
stu = pd.Series({'ID':41,'Name':'Abel','Score':99})
students = students.append(stu,ignore_index=True)
#下面是为第39行名字为Name和名字为Score的数据更换数据
students.at[39,'Name']='Bailey'
students.at[39,'Score']='120'
print(students)
#另一种替换方式,iloc按位置提取列数据。
stu = pd.Series({'ID':40,'Name':'Bailey','Score':120})
students.iloc[39] = stu
print(students)
#插入数据
stu = pd.Series({'ID':101,'Name':'Danni','Score':101})
part1 = students[:20]
part2 = students[20:]
students = part1.append(stu,ignore_index=True).append(part2).reset_index(drop=True)
print(students)
#删除函数,下面为删除0，1，2的数据
students.drop(index=[0,1,2],inplace=True)
#下面为删除0到10的数据
students.drop(index=students[0:10].index,inplace=True)
print(students)
#loc按标签提取数据
for i in range(5,15):
  students['Name'].at[i]=''
missing = students.loc[students['Name'] =='']
students.drop(index=missing.index,inplace=True)
students = students.reset_index(drop=True)
print(students)

列操作集锦

concat：用于数据合并。

import pandas as pd
import numpy as np
page_001 = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',sheet_name='Page_001')
page_002 = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',sheet_name='Page_002')
students = pd.concat([page_001],page_002).reset_index(drop=True)
#为Age这一列设置初始值为重复的25.
studnets['Age']=np.repeat(25,len(students))
#为Age设置0到最好的数值。
studnets['Age']=np.arange(0,len(students))
#删除两列的值
students.drop(columns=['Age','Score'],inplace=True)
#插入一列的值，1代表在第一列前面插入1列。
students.insert(1,column='Foo',value=np.repeat('foo',len(students)))
#将值列名改为大写
students.rename(columns={'Foo':'FOO','Name':'NAME'},inplace=True)
students['ID']=students['ID'].astype(float)
for i in range(5,15):
   students['ID'].at[i]=np.nan  #不符合数据的值都是np.nan
#凡是np.nan的值都将删除
students.dropna(inplace=True)
print(students)

读取数据库

sql server

import pandas as pd
import pyodbc
connection = pyodbc.connect('DRIVER={SQL Server};SERVER={local};DATABASE=AdventureWorks;USER=sa;PASSWORD=123')
#下面引号中内容是sql语句
query = 'select FirstName,LastName from Persons.Person'
#读取自定义数据read_sql_query
df1 = pd.read_sql_query(query,connection)
print(df1.head())

mysql

import pandas as pd
import pymysql
con = pymysql.connect(host='127.0.0.1',port=3306,user='root',password='12345',database='myss',charset='utf8')
sql = 'select aaa,bbb from myss.doubl'
df = pd.read_sql_query(sql,con)
print(df)

编写复杂方程

import pandas as pd
import numpy as np
def get_circumcircle_area(l,h):
#计算外接圆面积，sqrt对参数进行开方
    r = np.sqrt(l**2+h**2)/2
    return r**2*np.pi
def wrapper(row):
    return get_circumcircle_area(row['Length'],row['Height'])
rects = pd.read_excel('E:/pandas/pad/biaoge/Students.xlsx',index_col='ID')
rects['CA']=rects.apply(wrapper,axis=1)
print(rects)

import pandas as pd
import numpy as np
def get_circumcircle_area(l,h):
#计算外接圆面积，sqrt对参数进行开方
    r = np.sqrt(l**2+h**2)/2
    return r**2*np.pi
rects = pd.read_excel('E:/pandas/pad/biaoge/Rectangles.xlsx',index_col='ID')
rects['CA']=rects.apply(lambda row:get_circumcircle_area(row['length'],row['height']),axis=1)
print(rects)