pandas—dataframe操作

import pandas as pd
import numpy as np
#series：带标签的一维数组
#创建空对象
s = pd.Series()
print(s)
#通过列表创建
#index:设置series的标签，默认是以0开始的递增整数
s = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
print(s)
#通过ndarray创建
a = np.array([1,2,3,4,5])
s= pd.Series(a)
print(s)
#通过字典创建:会把字典中的key当作标签使用
dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
s = pd.Series(dic)
print(s)
#访问Seiers中的元素：通过标签名获取元素，而不再使用下标获取
item = s["a"]
print(item)

#遍历
#items（）：返回元素的标签和值
dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
s = pd.Series(dic)
for idx,val in s.items():
    print(idx, val)

#index遍历
for idx in s.index:
    print(idx, s[idx])

#values遍历：直接获取Series的value值
for value in s.values:
    print(value)

import pandas as pd
#DataFrame创建
#创建空对象
df = pd.DataFrame()
print(df)
#通过列表嵌套字典方式创建
#列表的字典中字段个数不一致，则按照最多的字段创建
data = [{"name":'zhangsan',"age":18,"address":'四川省'},{"name":'lis',"age":20,"sex":1}]
df = pd.DataFrame(data)
print(df)
#通过字典嵌套方式创建
data = {"name":['zhangsan','lisi','wangwu'],"age":[20,30,19]}
df = pd.DataFrame(data)
print(df)
#指定index和columns
#在创建dataframe时，不能直接修改columns，可以在创建后修改
df = pd.DataFrame(data,index=['a','b','c'],columns=['name','age'])
df.columns=['name1','age1']
print(df)

#通过Series创建
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data=data)
print(result)

import pandas as pd
import numpy as np

#访问行元素
#loc:使用标签名获取
data= {
    'A':[1,2,3,4],'B':[5,6,7,8],'C':[9,10,11,12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#获取a行数据
print(df.loc['a'])
#获取a行到c行的数据
print(df.loc['a':'c'])
#获取a行B列的值
print(df.loc['a','B'])
#行和列使用切片获取数据
print(df.loc['a':'c','A':'B'])
#通过行和列指定标签列表获取数据
print(df.loc[['a','c'],['A','C']])

#iloc：通过下标获取数据
data= {
    'A':[1,2,3,4],'B':[5,6,7,8],'C':[9,10,11,12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])

#获取第一行数据
print(df.iloc[0])

#获取第一行到第三行数据，使用iloc下标做切片，不包含结束值
print(df.iloc[0:2])

#行和列使用切片获取数据
print(df.iloc[0:2,0:2])

#添加数据行
#loc方法添加新行
data= {
    'A':[1,2,3,4],'B':[5,6,7,8],'C':[9,10,11,12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
#添加行的数据要与原dataframe一致
df.loc['e']=[13,14,15]
print(df)

#concat：连接dataframe
#按行连接
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
})
df3 = pd.concat([df1,df2],axis=0,ignore_index=True)
print(df3)

#按列连接
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})
df2 = pd.DataFrame({
    'C': [7, 8, 9],
    'D': [10, 11, 12]
})

df3 = pd.concat([df1,df2],axis=1)
print(df3)

#join:默认为outer（并集），inner（交集）
#按列拼接，join=inner,则按行取交集
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
},index=[0,1,2])

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
},index=[1,2,3])
df3 = pd.concat([df1,df2],axis=1,join='inner')
print(df3)

#按行拼接：join=inner,按列取交集
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
},index=[0,1,2])

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
},index=[1,2,3])
df3 = pd.concat([df1,df2],axis=0,join='inner')
print(df3)

#统计函数
#var:样本方差
#pandas默认使用样本方差，numpy默认使用总体方差
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50],
    'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)
print(df.var(axis=0))
print(df.var(axis=1))

import pandas as pd
import numpy as np
#访问列
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
result = pd.DataFrame(data)
print(result)
d = data['one']
print(d)

#添加一列数据：添加一个新列名，直接赋值即可
#新添加的数据长度要和原dataframe的行长度一致，否则会报错
result['three'] = [1,2,3,4]
print(result)

#assign：添加新列
#assign方法可以实现链式调用
#assign参数是一个赋值语句，等号左边是要添加的列名，右边是要添加的数据
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df = df.assign(three=[1,2,3,4]).assign(four=[5,6,7,8])
print(df)

#insert插入一列
#参数：loc-要插入的索引位置，column-要插入的列名，value-要插入的数据
df.insert(1,'five',[10,20,30,40])
print(df)

#修改数据
#获取以存在的值，直接赋值即可修改
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
# df['two'] = pd.Series([10,20,30,40],index = ['a', 'b', 'c', 'd'])
#与上句注释同效果
df['two']=[10,20,30,40]
print(df)

#修改列名
#rename:修改columns数据格式是一个字典，字典的key是原列名，value是新列名
#rename修改列名返回一个新的dataframe，原数据不受影响
#通过df.dolumns属性修改列名，是在原dataframe上直接修改
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df1=df.rename(columns={'one':'A','two':'B'})
print(df1)
print(df)

#astype:修改数据类型，修改的是某一列的数据类型
df1['B']=df1['B'].astype(np.float32)
print(df1)
#dtypes:返回dataframe的数据类型
print(df1.dtypes)

#删除
#drop（）：参数：labels-要删除的行或列的标签名，axis-指定要删除的轴，0（按行删除），1（按列删除），
# inplace-如果为True表示原地删除（在原dataframe上删除），为flase表示删除返回一个新的dataframe默认为Flase
#按行删除
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df1=df.drop(['one'],axis=1)
print(df1)

#删除行
data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df1=df.drop(['c','d'],axis=0)
print(df1)

#原地删除：inplace=True
df.drop(['c','d'],axis=0,inplace=True)
print(df)

import pandas as pd
import numpy as np

#重置索引

data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

#重置行索引
#如果要重置的索引中有新的行索引，则该行索引对应的数据默认填充NaN
#要重置的行索引可以调整顺序
new_index = ['b', 'a', 'c', 'd']
df1 = df.reindex(index=new_index)
print(df1)

#重置列索引
#如果要重置的索引中有新的列索引，则该列索引对应的数据默认填充NaN
#要重置的列索引可以调整顺序
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
idx = ['A', 'B', 'C','D']
df1 = df.reindex(columns=idx)
print(df1)

#重置索引
#method：做数据填充：ffill-向前填充，bfill-向后填充
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
idx = ['A', 'B', 'C','D']
df1 = df.reindex(columns=idx,method='ffill')
print(df1)
#fill_value:当行或列的数据为NaN,fill_value可以使用指定值填充
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
idx = ['A', 'B', 'C','D']
df1 = df.reindex(columns=idx,fill_value=0)
print(df1)

#Dataframe遍历
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data)
#直接遍历默认返回
for i in df:
    print(i)
#itertuples():遍历行，返回的是带标签的数据元组
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
}
df = pd.DataFrame(data)
for row in df.itertuples():
    print(row)
#index=Flase:在返回的行元组中去掉索引项，只保留数据
for row in df.itertuples(index=False):
    print(row)

#items():遍历列，返回的是列名和列数据
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
}
df = pd.DataFrame(data)

for col_index,col_value in df.items():
    print(f'index:{col_index},value{col_value}')

#使用index和columns属性遍历
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
}
df = pd.DataFrame(data)

for idx in df.index:
    for col in df.columns:
        print(df.loc[idx, col])

#排序
#sort_value（）：对数据进行排序
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data,index=['b', 'c','a'])

df1 = df.sort_values(['A'])
print(df1)

#多列排序
df2 = df.sort_values(['A','B'])
print(df2)

#acsending:设置升序或者降序，True-顺序（默认），False-降序
df2 = df.sort_values(['A','B'],ascending=False)
print(df2)

df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
})
#先按照Age降序排序，如果Age中有相同的数据，则再按照Score中数据按升序排列
df1 = df.sort_values(['Age','Score'],ascending=[False,True])
print(df1)