概述
安装pandas
命令：pip install pandas
查看是否安装包： pip list
pandas数据类型
Series是由相同数据类型组成的一维数组，大小不可变。
DataFrame：二维的表格型数据结构，数据帧(DataFrame)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）
面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是DataFrame的容器
一维数据结构：Series对象
#查看列索引
print(df2.columns)
#查看行索引
print(df2.index)
使用Pandas.Series
#pandas.Series(data,index,dtype,copy)
#data:数据，可以是序列类型，可以是int
#index：索引值必须是唯一的，与data的长度相同，默认为np.arange(n)
#dtype:数据类型
#cope:是否复制数据，默认为False
#打印左侧为索引，右侧为数据
import pandas as pd
import numpy as np
a = np.array([1,2,3,4,5])
s1 = pd.Series(a,index=['a','b','c','d','e'],copy = False)
#如果全部是int类型，那么打印s1会显示是int类型
s1 = pd.Series([1,2,3,4]) #dtype: int64
print(s1)
#如果什么数据类型都存在，那么打印s1会显示object类型的
s1 = pd.Series([1,"a",0.5,["张三","李四"]])#dtype: object
print(s1)
s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
s1 = pd.Series([1,2,3,4],index=['a','b','c','d'],dtype=np.float32)
"""
copy=True后，数据x不会改变，数据s1会改变
copy=False,数据x会改变，数据s1会改变
"""
x=np.array([10,20,30,40])
s1 = pd.Series(x,index=['a','b','c','d'],copy=True)
s1['a']=100
print(s1)
print(x)
从ndarray创建一个Series
x=np.array([10,20,30,40])
s1 = pd.Series(x)
s1 = pd.Series(x,index=['a','b','c','d'])
print(s1)
从字典创建一个Series
由于我们的Series有索引有数据，和我们的字典很像，字典是有key和vaule
#利用数据是字典的列表创建
#1. k变成列标签
#2.没有数据的用NaN
#a是索引 100数据
x={'a':100,'b':200,'c':300,'d':400}
s1 = pd.Series(x)
#设置索引
s1 = pd.Series(x,index=['a','b','c','d'])
#如果设置的索引位置换一下呢，数据也会跟着换
s1 = pd.Series(x,index=['a','c','d','b'])
#如果设置的索引，在字典中不存在呢，为nan
s1 = pd.Series(x,index=['a','b','e','f'])
print(s1)
单个索引获取数据
语法：s1[index] 获取单个数据
#可以使用默认索引，也可以使用自定义索引
s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
print(s1[0])
print(s1['a'])
多个索引获取数据
语法：
s1[list] 获取索引中的数据
s1[index1:index2] 获取从第一个索引到第二个索引的数据，左开右闭
Series对象的使用
| 属性和方法 | 说明 |
|---|---|
| axes | 返回Series索引列表 |
| dtype | 返回Series的数据类型 |
| empty | 判断Series是否为空，如果为空，则返回True |
| ndim | 返回基础数据的位数，默认为：1 |
| size | 返回基础数据中的元素个数 |
| values | 将Series作为ndarray返回 |
| head() | 返回前n行 |
| tail() | 返回最后n行 |
| T | 转置行和列 |
| ------ | -------------------------------------------------- |
| axes | 返回一个列，行轴标签和列轴标签作为唯一的成员 |
| dtypes | 返回此对象中的数据类型 |
| empty | 如果DataFrame为空，则返回为True，任何轴的长度都为0 |
| ndim | 数组维度大小，默认为2维 |
| shape | 返回表示DataFrame的维度的元组 |
| size | DataFrame中的元素个数 |
| values | 将DataFrame中的实际数据作为NDarray返回 |
| head() | 返回开头n行 |
| tail() | 返回最后n行
S3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
print(df2)
print('------cumprod-----累计乘积------------')
print(df2['age'].cumprod())
#print(df2)
#print('-----head-----------返回头几行---------')
#print(df2.head(2))
#print('-----tail-----------返回最后几行 ---------')
#print(df2.tail(2))
#print('-----values--把真正的数据转换成ndarray的形式输出-----')
#print(df2.values)
#print(type(df2.values))#<class 'numpy.ndarray'>
#print('-----size--------(元素个数)-----------')
#print(df2.size)#8
#print('-----shape--------(行和列)-----------')
#print(df2.shape)#(4, 2)
#print('-----ndim--------维度数-----------')
#print(df2.ndim)#2
#print('-----empty-------------------')
#print(df2.empty)#False
#print('-----dypes--------每一列的数据类型-----------')
#print(df2.dtypes)
#name object
#age int64
#dtype: object
#print('------axes--------获取行和列的索引-----------')
#print(df2.axes)#[Index(['row1', 'row2', 'row3', 'row4'], dtype='object'), Index(['name', 'age'], dtype='object')]
#print('--------------T--------转置----------------')
#print(df2.T)
创建空DataFrame对象
pandas.DataFrame( data, index, columns, dtype, copy)
data 支持多种数据类型，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
index 行标签，如果没有传递索引值，默认值为0,1,2,3,4.......
columns 列标签，如果没有传递索引值，默认值为0,1,2,3,4.......
dtype 每列的数据类型
copy 是否复制数据，默认值为False
df = pd.DataFrame()
print (df)
利用列表创建
#利用单层list
#数据变成行数据
#利用单层list
#数据变成行数据
import pandas as pd
import numpy as np
from pandas.core.frame import DataFrame
x=[1,2,3,4,5]
df2=pd.DataFrame(x)
print(df2)
#利用双层list
#如果是True，那么x数据不改
#利用双层list
x=[
['zs',20],
['ls',30],
['ch',40]
]
#df3=pd.DataFrame(x,columns=['name','age'])
#如果是True，那么x数据不改变
df3= pd.DataFrame(x,columns= ['name','age'],copy=True)
df3['age'] = 100
print(df3)
print(x)
#利用数据是字典的列表创建
#1. k变成列标签
#2.没有数据的用NaN
#index 行索引 columns列索引 NaN代表为空值利用双层list
x=[
{'a':20,'b':30},
{'a':100,'b':200,'c':400}
]
df4=pd.DataFrame(x)
print(df4)
#index 行索引 columns列索引 NaN代表为空值利用双层list
df4 = pd.DataFrame(x)
print(df4)
df4 = pd.DataFrame(x,index=["first","second"])
print(df4)
#如果没有c，就会默认是nun
df4 = pd.DataFrame(x,index=["first","second"],columns=['a','c'])
print(df4)
利用字典创建
#利用字典创建DataFrame
#a、b是列索引，一定要设置行索引（index），否则报错# 字典里面的v是列表类型创建DataFrame
#利用字典创建DataFrame
#a、b是列索引，一定要设置行索引(index),否则报错
x={'馒头':1,'包子':1.5,'豆浆':2,'倔强面':16}
df1=pd.DataFrame(x,index=['价格'])
#print(df1)
# 字典里面的v是列表类型创建DataFrame
#那么默认列索引是name和age
x={
'食品':['馒头','大米','包子'],
'价格':[1,2,1.5]
}
df2=pd.DataFrame(x)
#print(df2)
S1=pd.Series(['馒头','大米','包子'])
S2=pd.Series([1,2,1.5])
x={
'食品':S1,
'价格':S2
}
df3=pd.DataFrame(x)
print(df3)
列的读取
####列的读取
#df[colums_lable] 查询单列
#df[[colums_lable]] 查询多列
#查询出一列会进行降维DataFrame-------->Series
S1=pd.Series(['馒头','大米','包子'])
S2=pd.Series([1,2,1.5])
x={
'食品':S1,
'价格':S2
}
df3=pd.DataFrame(x)
print(df3)
s=df3['食品']
print(s)
print(type(s)) #<class 'pandas.core.series.Series'>
s2=df3[['食品','价格']]
print(s2)
print(type(s2)) #<class 'pandas.core.frame.DataFrame'> 查一列，降维，查多列不会降维
列的添加
#列的添加
# #df[columns]=数据
#切记数据要是同类型的数据
#df1[columns]=df1[columns]+df1[columns]
S1=pd.Series(['馒头','大米','包子'])
S2=pd.Series([1,2,1.5])
x={
'食品':S1,
'价格':S2
}
df3=pd.DataFrame(x)
print(df3)
a =['好吃','多','陷多']
df3['评价']=a
#print(df3)
print("-----------------")
df3['详细评价']=df3['食品']+df3['评价']
print(df3)
列的删除
##删除语法：
#dfl df[columns] 根据下标进行检索删除，没有返回值
#dfl.pop[columns] 根据下标进行检索删除，并返回删除的那一列
#列的添加
# #df[columns]=数据
#切记数据要是同类型的数据
#df1[columns]=df1[columns]+df1[columns]
S1=pd.Series(['馒头','大米','包子'])
S2=pd.Series([1,2,1.5])
x={
'食品':S1,
'价格':S2
}
df3=pd.DataFrame(x)
print(df3)
a =['好吃','多','陷多']
df3['评价']=a
#print(df3)
print("-----------------")
df3['详细评价']=df3['食品']+df3['评价']
print(df3)
##删除语法：
#dfl df[columns] 根据下标进行检索删除，没有返回值
#dfl.pop[columns] 根据下标进行检索删除，并返回删除的那一列
del df3['评价']
print(df3)
a=df3.pop('详细评价')
print('a',a)#要删除的那一列数据
print('df3',df3) #删除后的数据
行的读取
使用loc方法
#行读取数据
#loc[自定义索引(标签索引)]
#iloc[默认索引(数字索引)]
#语法：
#loc[index] 查询一行数据
#扩展
#loc[index,columns] 精确到行和列，那就是一个数据
#查询多行和多列（精确到第几行和第几列）
#loc[[index1,index2,....],[columns1,columns12,.....]]
#查询多行和多列（第几行到第几行,第几列到第几列）
#不是左开右闭
#loc[index1:index2,columns1:columns2]
#使用布尔索引也可以查询多行多列
#loc[行_布尔索引,列_布尔索引]
S1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],
index=['row1','row2','row3','row4','row5','row6','row7',])
S2=pd.Series([1,2,1.5,12,16,10,8],
index=['row1','row2','row3','row4','row5','row6','row7',])
S3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],
index=['row1','row2','row3','row4','row5','row6','row7',])
x={
'食品':S1,
'价格':S2,
'评价':S3
}
df3=pd.DataFrame(x)
#print(df3)
#print(df3.loc['row1'])
#print(df3.loc['row4','食品'])
#print(df3.loc[['row1','row3',],['食品','价格']])
#print(df3.loc[['row1','row3'],'食品'])
#print(df3.loc['row1',['食品','价格']])
#print(df3.loc[['row1','row4'],'食品':'价格'])
index_bool = [True,False,False,False,False,True,True]
col_bool = [True,True,False]
print(df3.loc[index_bool,col_bool])
#b = df3['价格']>8
#print(df3.loc[b])
使用df.iloc方法
df.loc方法，根据行、列的标签值查询
df.iloc方法 根据行、列的数字位置查询
#查询行的，iloc[数字索引]
#语法：
#iloc[num_index] 根据索引位置获取行
#iloc[num_index1:num_index2] 第几行到第几行,左开右闭
#iloc[[num_index1,num_index2,.....]] 第几行和第几行
#iloc[num_index,num_columns] #第几行的第几列
#iloc[num_index,[num_columns1,num_columns2,....]] 第几行，第几列和第几列
#iloc[num_index,[num_columns1:num_columns2]] 第几行，第几列到第几列,左开右闭
#iloc[[num_index1,num_index2,.....],[num_columns1,num_columns2,....]]
S1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],
index=['row1','row2','row3','row4','row5','row6','row7',])
S2=pd.Series([1,2,1.5,12,16,10,8],
index=['row1','row2','row3','row4','row5','row6','row7',])
S3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],
index=['row1','row2','row3','row4','row5','row6','row7',])
x={
'食品':S1,
'价格':S2,
'评价':S3
}
df3=pd.DataFrame(x)
#查询行的，iloc[数字索引]
print(df3.iloc[0])
#print(df3.iloc[0:4])
#print(df3.iloc[[0,3]])
#print(df3.iloc[6,0])
#print(df3.iloc[6,0:2])
#print(df3.iloc[6,[0,2]])
#print(df3.iloc[[0,2,4],[0,2]])
使用切片读取
df[nu_index1:num_index2]第几行到第几行 左开右闭---切片
df[label_index1:label_index2]第几行到第几行 左开右开
S1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],
index=['row1','row2','row3','row4','row5','row6','row7',])
S2=pd.Series([1,2,1.5,12,16,10,8],
index=['row1','row2','row3','row4','row5','row6','row7',])
S3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],
index=['row1','row2','row3','row4','row5','row6','row7',])
x={
'食品':S1,
'价格':S2,
'评价':S3
}
df3=pd.DataFrame(x)
print(df3[0:4])#第一行到第五行 ，但是第五行取不到
print(df3['row1':'row4'])#第一行到第四行，第四行能取到
行的添加
在末尾追加一行 ，返回一个新对象
df.append(other,ignore_index= False,verify_interity = False,sort = False)
other:要附加的数据，DataFrame或者Series等类型
ignore_index:如果是True,则不适用索引标签，默认false
verify——integrity：如果是true ，在创建于重复项的索引时，引发value error，默认时false
sort：如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
S1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],
index=['row1','row2','row3','row4','row5','row6','row7',])
S2=pd.Series([1,2,1.5,12,16,10,8],
index=['row1','row2','row3','row4','row5','row6','row7',])
S3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],
index=['row1','row2','row3','row4','row5','row6','row7',])
x={
'食品':S1,
'价格':S2,
'评价':S3
}
df3=pd.DataFrame(x)
'''
print(df3[0:4])#第一行到第五行 ，但是第五行取不到
print(df3['row1':'row4'])#第一行到第四行，第四行能取到'''
'''
在末尾追加一行 ，返回一个新对象
df.append(other,ignore_index= False,verify_interity = False,sort = False)
other:要附加的数据，DataFrame或者Series等类型
ignore_index:如果是True,则不适用索引标签，默认false
verify——integrity:如果是true ，在创建于重复项的索引时，引发value error，默认时false
sort:如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
'''
print("---------------------")
df1 = df3.append(df3,verify_integrity=False)
print(df1)
print("----------append(ignore_index)-----------")
df1 = df3.append(df3,ignore_index=True)
print(df1)
行的删除
#df1 = df.drop(index) 删除某行，返回一个新数据
#index 只能是索引标签（自定义索引）
S1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],
index=['row1','row2','row3','row4','row5','row6','row7',])
S2=pd.Series([1,2,1.5,12,16,10,8],
index=['row1','row2','row3','row4','row5','row6','row7',])
S3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],
index=['row1','row2','row3','row4','row5','row6','row7',])
x={
'食品':S1,
'价格':S2,
'评价':S3
}
df3=pd.DataFrame(x)
'''
print(df3[0:4])#第一行到第五行 ，但是第五行取不到
print(df3['row1':'row4'])#第一行到第四行，第四行能取到'''
'''
在末尾追加一行 ，返回一个新对象
df.append(other,ignore_index= False,verify_interity = False,sort = False)
other:要附加的数据，DataFrame或者Series等类型
ignore_index:如果是True,则不适用索引标签，默认false
verify——integrity:如果是true ，在创建于重复项的索引时，引发value error，默认时false
sort:如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
'''
'''
print("---------------------")
df1 = df3.append(df3,verify_integrity=False)
print(df1)
print("----------append(ignore_index)-----------")
df1 = df3.append(df3,ignore_index=True)
print(df1)'''
#df1 = df.drop(index) 删除某行，返回一个新数据
#index 只能是索引标签（自定义索引）
df1 = df3.drop('row4')
print(df1)
DataFrame的属性和方法
| T | 转置行和列 |
| ------ | -------------------------------------------------- |
| axes | 返回一个列，行轴标签和列轴标签作为唯一的成员 |
| dtypes | 返回此对象中的数据类型 |
| empty | 如果DataFrame为空，则返回为True，任何轴的长度都为0 |
| ndim | 数组维度大小，默认为2维 |
| shape | 返回表示DataFrame的维度的元组 |
| size | DataFrame中的元素个数 |
| values | 将DataFrame中的实际数据作为NDarray返回 |
| head() | 返回开头n行 |
| tail() | 返回最后n行
S3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
print(df2)
print('------cumprod-----累计乘积------------')
print(df2['age'].cumprod())
#print(df2)
#print('-----head-----------返回头几行---------')
#print(df2.head(2))
#print('-----tail-----------返回最后几行 ---------')
#print(df2.tail(2))
#print('-----values--把真正的数据转换成ndarray的形式输出-----')
#print(df2.values)
#print(type(df2.values))#<class 'numpy.ndarray'>
#print('-----size--------(元素个数)-----------')
#print(df2.size)#8
#print('-----shape--------(行和列)-----------')
#print(df2.shape)#(4, 2)
#print('-----ndim--------维度数-----------')
#print(df2.ndim)#2
#print('-----empty-------------------')
#print(df2.empty)#False
#print('-----dypes--------每一列的数据类型-----------')
#print(df2.dtypes)
#name object
#age int64
#dtype: object
#print('------axes--------获取行和列的索引-----------')
#print(df2.axes)#[Index(['row1', 'row2', 'row3', 'row4'], dtype='object'), Index(['name', 'age'], dtype='object')]
#print('--------------T--------转置----------------')
#print(df2.T)
| count() | 非空数据的数量 |
| --------- | ---------------- |
| sum() | 所有值之和 |
| mean() | 所有值的平均值 |
| median() | 所有值的中位数 |
| mod() | 值的模 |
| std() | 值的标准偏差 |
| min() | 所有值中的最小值 |
| max() | 所有值中的最大值 |
| abs() | 绝对值 |
| prod() | 数组元素的乘积 |
| cumsum() | 累积总和 |
| cumprod() | 累计乘积 |
S3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
print(df2)
#print('------cumsum-----累计求和------------')
#print(df2.cumsum())
#print('------prod-----乘积------------')
#print(df2['age'].prod())
#print('------abs-----绝对值------------')
#print(df2['age'].abs())
#print('------min-----最小值------------')
#print(df2.min())
#print('------std-----标准差------------')
#print(df2.std())
#print('------mod(n)-----取余------------')
#print(df2['age'].mod(2))
#print('------median()-----中位数------------')
#print(df2.median())
#print('------mean()-----平均值----每一列的平均值----')
#print(df2.mean())
#print('------sum()-----求和----每一列的和----')
#print(df2.sum())
#print('-------count()--------- 非空计数-----')
#print(df2.count())
函数是用来计算有关DataFrame列的统计信息的摘要
describe(percentiles = None,include = None,exclude = None,datetime_is_numeric = False)
percentiles:设置分位数，默认是[.25，.5，.75],
include:计算哪些数据类型的统计量
object: -汇总字符串列
number: - 汇总数字列
all:-将所有列汇聚在一起(不应将其作为列表值传递)
exclude:不计算哪些数据类型的统计量，参数和上面一样 ，没有all
datetime_is_numeric:默认值为False。设置为Ture可将日期时间数据视为数字
from numpy.lib.shape_base import split
import pandas as pd
import numpy as np
from pandas.core.frame import DataFrame
'''
函数是用来计算有关DataFrame列的统计信息的摘要
describe(percentiles = None,include = None,exclude = None,datetime_is_numeric = False)
percentiles:设置分位数，默认是[.25，.5，.75],
include:计算哪些数据类型的统计量
object: -汇总字符串列
number: - 汇总数字列
all:-将所有列汇聚在一起(不应将其作为列表值传递)
exclude:不计算哪些数据类型的统计量，参数和上面一样 ，没有all
datetime_is_numeric:默认值为False。设置为Ture可将日期时间数据视为数字
'''
S1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
S2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':S1,
'age':S2,
}
df1 = pd.DataFrame(x)
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
print(df2)
a= df2.describe(exclude='number')
print(a)
print(df2.describe(percentiles=[.20,.70,.90]))
| lower() | 将Series/Index中的字符串转换为小写 |
| ------------------- | ------------------------------------------------------------ |
| upper() | 将Series/Index中的字符串转换为大写 |
| len() | 计算字符串长度 |
| strip() | 帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符) |
| split(' ') | 用给定的模式拆分每个字符串 |
| cat(sep=' ') | 使用给定的分隔符连接系列/索引元素 |
| get_dummies() | 返回具有单热编码值的数据帧(DataFrame) |
| contains(pattern) | 如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False |
| replace(a,b) | 将值a替换为值b |
| repeat(value) | 重复每个元素指定的次数 |
| count(pattern) | 返回模式中每个元素的出现总数 |
| startswith(pattern) | 如果系列/索引中的元素以模式开始，则返回true |
| endswith(pattern) | 如果系列/索引中的元素以模式结束，则返回true |
| find(pattern) | 返回模式第一次出现的位置 |
| findall(pattern) | 返回模式的所有出现的列表 |
| swapcase() | 变换字母大小写 |
| islower() | 检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值 |
| isupper() | 检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值 |
| isnumeric() | 检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值 |
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
print('----count (value)----')
df_name =df2['name']
print(df_name.str.count('黄'))
#print('----repeat (n)----')
#df_name =df2['name']
#print(df_name.str.repeat(3))
#print('----replace --替换--')
#df_name =df2['name']
#print(df_name.str.replace('富贵','栓柱'))
#print('----contains(value) --是否包含--')
#df_name =df2['name']
#print(df_name.str.contains('蛋'))
#print('----get_dummies() --寄存器编码--')
#df_name =df2['name']
#print(df_name.str.get_dummies())
#print('----cat(sep)----')
#df_name =df2['name']
#df_cat = df_name.str.cat(sep='==')
#print(df_cat)
#print('----拆分----')
#df_name =df2['name']
#df_split = df_name.str.split(',')
#df_row1 = df_split.loc['row1']
#print(df_row1[1])
#print('----去空----')
#df_name =df2['name']
#df_strip = df_name.str.strip()
#print(df_strip)
#df_strip = df_name.str.len()
#print(df_strip)
#print('----len()----每个名字的长度----')
#df_name =df2['name']
#print(df_name.str.len())
#pipe(gunc,*args,**kwargs)
# func:函数意味着，我们自定义函数需要多个参数的时候可以进行传递
# *args,**kwargs :
def chang_name(df):
df_name = df['name']#获取名字
df_re = df_name.str.repeat(3)#名字重复多少次
return df_re
df3 = df2.pipe(chang_name)
#print(df3)
def add_age(df,i):
df['age'] = df['age'] + i
return df
df4 = df2.pipe(add_age,2)
print(df4)
添加列
#添加列
df2['score']= [10,20,30,40]
print(df2)
#修改乘机十分制
def change_score(df2,i):
df2['score'] = df2['score'] / i
return df2
#调用函数
df5 = df2.pipe(change_score,10)
print(df5)
自定义函数
自定义函数，把数据放到函数中进行应用/转换，成我们想要的数据
apply(func,axis= 0,raw= False,result_type=None,args=(),**kwargs)
func:作用于每一行和每一列
axis：所对应的轴，默认是0
0或者index:代表每一列
1或者columns:代表每一行
raw：布尔类型，默认是False
如果时False：将每一行和每一列作为Series传递给函数
如果时True：将数据作为ndarry传递给函数
result_type : {'expand', 'reduce', 'broadcast', None}，默认是none
expand：类似列表的结果转换成DataFrame的列
reduce：如果可能，返回一个Series或DataFrame，而不是类似列表的结果，和expand相反
broadcast:结果保留原始索引和列
def is_dtype(df):
return df.dtype
a = df2.apply(is_dtype,raw=False)
print(a)
print("--------------expand：类似列表的结果转换成DataFrame的列-------------------------")
def a(data):
return [1,2]
#意思是df作为参数传给is_sex(df) ，并且把数据作为列进行添加
df2 = df2.apply(a,axis=1,result_type="expand")
print(df2)
"""
--------------expand:类似列表的结果转换成DataFrame的列-------------------------
0 1
row1 1 2
row2 1 2
row3 1 2
"""
print("--------------reduce:如果可能，返回一个Series-------------------------")
def a(data):
s = pd.Series([1,2],index=['one','two'])
return s
#意思是df作为参数传给is_sex(df) ，并且把数据作为列进行添加
df2 = df2.apply(a,axis=1,result_type="reduce")
print(df2)
print(type(df2))
"""
--------------reduce:如果可能，返回一个Series-------------------------
one two
row1 1 2
row2 1 2
row3 1 2
<class 'pandas.core.frame.DataFrame'>
"""
print("-------------- broadcast:结果保留原始索引和列-------------------------")
def a(data):
return [1,2]
#意思是df作为参数传给is_sex(df) ，并且把数据作为列进行添加
df2 = df2.apply(a,axis=1,result_type="broadcast")
print(df2)
"""
-------------- broadcast:结果保留原始索引和列-------------------------
name age
row1 1 2
row2 1 2
row3 1 2
"""
#使用applymap，那么df是一个整体
#基于切片的
#df[列索引]
#print(df2['name'])
#print(df2['age'])
#基于标签索引的
#df2.loc[]
from numpy.lib.shape_base import split
import pandas as pd
import numpy as np
from pandas.core.frame import DataFrame
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([10,10,10,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
#使用applymap，那么df是一个整体
'''
def add_age(df):
if isinstance(df,float):
return df+1
else:
return df
print("-----------------------------")
a=df2.applymap(add_age)
print(a)
#使用apply,df参数是列或者行进行传递的
def add_age1(df):
#columns 获取列索引
#print(df.index) # Index(['name','age'],dtype='object')
a=df.index
if a[1]=='age':
df['age']=df['age'] + 1
return df
else:
return df
b=df2.apply(add_age1,axis=1)
print(b)'''
df2.loc['row1']
df2.loc['row1','name']
df2.loc[['row1','row3'],['name','age']]
df2.loc['row1':'row3','name':'age']#语法：
#df.index=值
#df.columns=值
df2.index=[0,1,2,3]
print("------------------------------")
print (df2)
df2.columns=['姓名','年龄']
print("------------------------------")
print (df2)#df.rename(index={旧行索引:新行索引},columns={旧列索引:新列索引}) 有返回值
'''
df1 = df2.rename(index={'row4':'花钱','row2':'vip'})
print("------------------------------")
#print (df1)
df3= df2.rename(columns={'name':'姓名','age':'年龄'})
print("------------------------------")
print (df3)
'''
迭代
#普通的for循环，只能遍历出列索引的名字
#iteritems() - 迭代(key(列索引)，value(列值对))
#iterrows() - 将行迭代为(索引，值)对
#itertuples() - 以tuples的形式迭代行
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([20,10,50,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
#[i for i in df2] 推导式
#for i in df2:
#print(i)
print('------------------iteritems-------------------')
for k,v in df2.iteritems():
print(k,v)
#print('------------------------iterrows--------------------')
#for k,v in df2.iterrows():
# print(k)
# print(v)
#print('------------------------itertuples--------------------')
#for row in df2.itertuples():
#print(row)
排序
#按照值进行排序
#sort_values(by,axis = 0 ,ascending = Ture , inplace = False,
# kind = "quicksort",na_position = "last",ignore_index = False)
# by:按照那一列排序
# axis：axis = 0或index，则按照指定列中数据大小排序
# axis = 1或columns ，则按照指定索引中数据大小排序，默认axis = 0
# ascending：Ture是升序， False是降序、逆序
# inplace：是否用排序后的数据集替换原来的数据 ，默认 False，既不替换
# kind = "quicksort"：排序算法，不用修改
# quicksort：快速排序
# mergessort：稳定排序
# heapsort：堆排序算法
# na_position：空值放在那里，默认放在last(面) first放在前面
# ignore_index = False：忽略索引，默认是不忽略(False) ,忽略(Ture)
#
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([20,10,50,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
a = df2.sort_values('age',axis=0,ascending=False,na_position='first',ignore_index=True,inplace=True)
print(a)
print('-------------------------')
print(df2)
#按照索引进行排序
#sort_index(axis = 0 , level=None,ascending = Ture , inplace = False,
# kind = "quicksort",na_position = "last",ignore_index:bool = False)
# axis：axis = 0或index，则按照指定列中数据大小排序
# axis = 1或columns ，则按照指定索引中数据大小排序，默认axis = 0
#level：默认None，若不为None，则对指定索引级别的值进行排序
# ascending：Ture是升序， False是降序、逆序
# inplace：是否用排序后的数据集替换原来的数据 ，默认 False，既不替换
# kind = "quicksort"：排序算法，不用修改
# quicksort：快速排序
# mergessort：稳定排序
# heapsort：堆排序算法
# default ‘quicksort’
# na_position：空值放在那里，默认放在last(后面) first放在前面
# ignore_index = False：忽略索引，默认是不忽略(False) ,忽略(Ture)
S3=pd.Series(['大黄,小黄','狗蛋 ',' 铁蛋',' 富贵'],
index=['row1','row2','row3','row4'])
S4=pd.Series([20,10,50,np.NaN],
index=['row1','row2','row3','row4'])
x1={
'name':S3,
'age':S4,
}
df2 = pd.DataFrame(x1)
a = df2.sort_index(axis=1,ascending=False)
print(a)
#take(indices, axis=0, is_copy = None)
#indices:按照那个顺序进行排序,可以是序列类型，也可以是ndarray类型
# 也可以使用numpy.random.permutation(n)函数随机产生数据
#axis : 0 or 'index'，代表按照行
# 1 or 'columns'，代表按照列
# 默认是 0
#is_copy：是否拷贝，默认是True.
#np.random.permutation(n) 根据n随机排序产生0-n的不同数据的整数
#比如np.random.permutation(3) 那就是0，1，2，随机排序产生，有可能是[0,2,1],huo[2,1,0]等
s3=pd.Series(['大黄,小黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3',np.NaN])
s4=pd.Series([20,10,50,np.NaN],index=['row1','row2','row3',np.NaN])
x1={
'name':s3,
'age':s4
}
df2=pd.DataFrame(x1)
a=np.array([0,3,1,2])
#df_take=df2.take(a)
b=[1,0]
#df_take=df2.take(b,axis=1)
c=np.random.permutation(4)
df_take=df2.take(c,axis=0)
print(df_take)
Pandas合并
#pd.merge(left,right, how="inner",on= None,left_on= None,right_on= None,
# left_index= False,right_index= False,
# suffixes = ("_x", "_y"),copy= True,indicator= False)
#left:需要连接的数据
#right:需要连接的数据
#how:str类型的，{'left', 'right', 'outer', 'inner'}中选一个
#on：指定用于连接的列标签的名字，列标签必须同时存在于左右两个 DataFrame 中，
# 如果为none，那么以两个 DataFrame 的列名交集做为连接键。
#left_on：指定左侧 DataFrame 中作连接键的列名
#right_on：指定右侧 DataFrame 中作连接键的列名
#left_index：布尔参数，默认为none。如果为 True 则使用左侧 DataFrame 的行索引作为连接键。
#right_index 布尔参数，默认为none,如果为 True 则使用右侧 DataFrame 的行索引作为连接键。
#suffixes：当左右 DataFrame 存在相同列名时，通过该参数可以在相同的列名后附加后缀名，默认为('_x','_y')。
#indicator：设置为 True；用来表示 DataFrame 会添加新的一列 ，列名为_merge； 来表示各行的合并类型信息。
# 也可以设为 String ，自定义列名
dict01 = {
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu = pd.DataFrame(dict01)
'''
'''
dict02 = {
'name':['zs','ls','zl','ch','eg'],
'score':[60,70,80,90,40]
}
sco= pd.DataFrame(dict02)
#a= pd.merge(stu,sco,how='left',left_on='name',right_on='姓名')
#a= pd.merge(stu,sco,left_index=True,right_index=True)
a= pd.merge(stu,sco,how='right',left_index=True,right_index=True,suffixes=('_1','_2'),indicator='合并信息')
print(a)
#df.join(other) 函数更合适于根据索引进行合并
#注意：join按照索引进行合并，列索引和行索引一定不能一样
dict01 = {
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu = pd.DataFrame(dict01)
'''
'''
dict02 = {
'姓名':['zs','ls','zl','ch','eg'],
'score':[60,70,80,90,40]
}
sco= pd.DataFrame(dict02)
pandas拼接
#pd.concat(objs,axis=0,join = "outer",ignore_index = False,keys=None,
# names=None,verify_integrity= False,sort= False,copy = True,)
#objs series，dataframe或者是panel构成的序列list
#axis 表示在哪个轴方向上（行或者列）进行连接操作，默认 axis=0 表示行方向。axsi=1表示列方向
#join 指定连接方式，取值为{"inner","outer"}，默认为 outer 表示取并集，inner代表取交集。
#ignore_index 布尔值参数，默认为 False，如果为 True，表示不在连接的轴上使用索引。
#keys list类型，给连接的两个数据指定的键(分层索引)
#names：list类型，默认无。使用keys创建分层索引时，可以利用names给分层索引名字
#verify_integrity：如果是True，在创建于重复项的索引时，引发valueError，默认时false
#sort：排序非串联轴，如果它在连接为"outer"时尚未对齐，使用True则对齐;默认值是False
#copy：True拷贝一个新数据，默认是True。False不拷贝
dict01={
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
student=pd.DataFrame(dict01)
dict02={
'name':['zs','ls','zl','ch','eg'],
'score':[60,70,80,90,40]
}
score=pd.DataFrame(dict02)
#a=pd.concat([student,score],verify_integrity=True)
#a=pd.concat([student,score],ignore_index=True)
#a=pd.concat([student,score],keys=['student','score'],names=['fc','hang'])
#a=pd.concat([student,score],axis=1,join='inner')# inner代表取交集。
a=pd.concat([student,score],axis=1,join='outer') #outer 表示取并集
print(a)
pandas删除
drop( )
del( )
#drop(labels=None,axis: Axis = 0,index=None,columns=None,
# inplace: bool = False,errors: str = "raise",)
#labels：要删除的数据索引，一定要和axis结合，如 (labels='A', axis=1) 表示A列
#axis：axis=0表示行，axis=1表示列,默认是0
#columns：要删除的列名
#index：要删除的行名，表示dataframe的index, 如index=1, index=a
#inplace：True表示在原数据上删除，没有返回值，
# False不在原始数据上删除，返回一个新的数据
#del:删除指定列
dict01={
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu=pd.DataFrame(dict01)
#df01=stu.drop(columns='age')
#df01=stu.drop(labels='age',axis=1)
#df01=stu.drop(index=[0,3,5]) #删除多行
df01=stu.drop(labels=[0,3,5],axis=0,inplace=True)
print(df01)
print('----------------------------')
print(stu)
##del :删除指定列
print('----删除name这一列-------------')
del stu['name']
print(stu)
duplicated( ）
#检测重复的数据，返回布尔值
#duplicated(subset: Hashable | Sequence[Hashable] | None = None,
# keep: Literal["first"] | Literal["last"] | Literal[False] = "first")
#subset:查找特定列上的重复项，默认是none
#keep:作用取决于值，值有三个first，last，False，默认是first
# first:第一个重复的值为False代表不重复，其他所有的值为True，代表重复
# last:最后以个重复的值为False代表不重复，其他所有的值为True，代表重复
# False:不重复的为False，所有重复的为True
dict01={
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu=pd.DataFrame(dict01)
a = stu.duplicated(subset='sex',keep='first')
print(a)
a=stu.duplicated(subset='sex',keep='first')
#a=stu.duplicated(subset='sex',keep='last')
#a=stu.duplicated(subset='sex',keep=False)
print(a)
#df01=stu.loc[a]
#print(df01)
'''
##把第一次重复的年龄保留，以后重复的年龄删除
print('--第一种--简单数据------')
a=stu.drop(index=[3,5])
print(a)
#第二种
a = stu.duplicated(subset='age',keep='first')
print(a)
def change(bo):
if bo:
return False
else:
return True
#把Ture变成false false变成True
change = lambda bo:False if bo else True
age_zz = a.apply(change)
print(stu.loc[age_zz])
print('-----第三种------')
a=stu.drop_duplicates(subset='age',keep='first',ignore_index=True)
print(a)'''
drop_duplicates()
#df.drop_duplicates(subset: Hashable | Sequence[Hashable] | None = None,
# keep: Literal["first"] | Literal["last"] | Literal[False] = "first",
# inplace: bool = False,ignore_index: bool = False)
#subset:表示要进去重的列名，默认为 None。
#keep:有三个可选参数，分别是 first、last、False，默认为 first，
# 表示只保留第一次出现的重复项，删除其余重复项，last 表示只保留最后一次出现的重复项，False 则表示删除所有重复项。
#inplace:布尔值参数，默认为 False 表示删除重复项后返回一个副本，
# 若为 Ture 则表示直接在原数据上删除重复项。
#ignore_index= False:忽略索引，默认是不忽略（False），True:忽略
dict01={
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu=pd.DataFrame(dict01)
print(stu)
print('--------------------')
df02=stu.T #转置
print(df02)
按等级索引旋转
#Stack()入(Stacking):旋转数据结构，把列转换为行
#UnStack出栈(UnStacking):把行转换为列
dict01={
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu=pd.DataFrame(dict01)
print(stu)
print('----列变成行----------')
student01=stu.stack()
#print(student01)
print('-------UnStack----行变成列----')
student02=stu.unstack()
print(student02)
长格式向宽格式旋转
#df.pivot(index=None, columns=None)
#index:设置重塑的新表的行索引名称，一定是存在的索引
#columns:设置重塑的新表的列名称，一定是存在的索引
dict01 = {
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu = pd.DataFrame(dict01)
print(stu)
a = stu.pivot(index='name',columns='age')
print(a)
#透视表，获取需要的数据并且针对数据进行函数操作
# pivot_table(values,index,aggfunc)
#values:需要数据的表名
#index：一定是存在的索引按照index进行统计
#aggfunc：字典类型 ，可以设置不同列的不同函数
dict01 = {
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu = pd.DataFrame(dict01)
print(stu)
a = stu.pivot_table(values={'name','age'},index='sex',aggfunc={'name':'count','age':'sum'})
print(a)
#groupby(by,axis) 分组
#by:按照那个数据分组。列名、数据、字典、Series、函数
#axis：默认是0，
# 0：按照行 1：按照列
dict01 = {
'name':['zs','ls','zl','ww','ch','eg'],
'age':[20,18,10,18,19,20],
'sex':['g','b','b','b','b','g']
}
stu = pd.DataFrame(dict01)
print('-----------------按照性别分组--------------------')
a = stu.groupby('sex')
for i in a:
print(i)
print('-----------------按照性别分组--------------------')
s_sex =stu['sex']
b= stu.groupby(s_sex)
for i in b:
print(i)
print('-----------------按照字典分组--------------------')
dict02 = {
0:'一班',
1:'二班',
2:'三班',
3:'二班',
4:'一班',
5:'三班'
}
c = stu.groupby(dict02)
for i in c:
print(i)
print('-----------------按照函数分组--------------------')
#按照每一列，类名的长度分组
d= stu.groupby(len,axis=1)
for i in d:
print(i)
最后
以上就是柔弱小土豆为你收集整理的第八章Pandaspandas数据类型一维数据结构：Series对象的全部内容，希望文章能够帮你解决第八章Pandaspandas数据类型一维数据结构：Series对象所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复