pandas数据操作

import pandas as pd

import numpy as np

# Series是一个一维数组的对象

# 1.通过列表创建Series对象
# 由索引和数据组成的，左边是索引 右边是数据

ser_obj = pd.Series(range(10,20))

# 获取索引 RangeIndex是索引的类型

print(ser_obj.index)
# 获取值
print(ser_obj.values)
# head()函数 默认查看前5条数据 ，可以传入制定查看数据的条数
print(ser_obj.head())
# 根据索引取出数据
print(ser_obj[5])
# 基本运算
print(ser_obj**2)
# 筛选数据
print(ser_obj>15)
# 取出符合条件的数据
print(ser_obj[ser_obj>15])

# 2.通过字典构建series对象,字典中的key作为索引，值作为值 索引类型：Int64Index

student = {
    2001:15.5,
    2005:20.4,
    2008:26.5
}

# 传入字典

ser_obj = pd.Series(student)

# 指定索引名称

ser_obj.index.name = 'year'

# 指定series对象名称

ser_obj.name = 'GDP'

# 3.手动指定索引和数据类型
# 1.数据  2.index=索引列表

ser_obj = pd.Series(['张三','李四','王五'],index=['a','b','c'])
ser_obj = pd.Series(['10','20','30'],index=['a','b','c'],dtype='float32')
print(ser_obj)

# DataFrame类
# 类似多维数组/表格数据
# 分为行索引和列索引
# 每列的数据可以是不同的类型

# 创建二维数组
# randn() 生成带有正负值的数据

arr = np.random.randn(3,4)

# 通过ndarrary创建dataframe对象
# 二维数组中每一个小数组中的数据在dataframe中是一行
# 二维数组中每一个小数组中对应索引的数据在dataframe中是一列
# 指定行索引和列索引
# index 指定行索引   columns指定列索引

df_obj = pd.DataFrame(arr,index=['a','b','c'],columns=['name','age','phone','sex'])

# 通过字典创建DataFrame对象
# 保证数据中至少有一个列数据是带有行索引的
# key作为列索引  value作为一列数据

dict_data = {

    'A':1,
    'B':pd.Series(range(4),index=list(range(4)),dtype='int32'),
    'C':np.array(range(4,8),dtype='int32'),
    'D':4,
    'E':'hello',
    'F':6

}

df_obj = pd.DataFrame(dict_data)

# 通过索引取出某一列的数据

print(df_obj['C'])
print(type(df_obj['C']))
# 通过属性获取某一列数据，如果列名中有空格，会导致获取失败
# print(df_obj. B)

# 修改数据
df_obj['C'] = pd.Series('world',index=list(range(4)))
print(df_obj)
# 添加新列
df_obj['G'] = df_obj['B']*2
print(df_obj)
df_obj['H'] = '你好'
print(df_obj)
# 删除列
del(df_obj['H'])
print(df_obj)

# 查看索引
# Series和DataFrame对象的索引都是Index对象
# 索引对象不可变，为了保证数据的安全性
# Index  Int64Index RangeIndex（默认）  DateTimeIndex 时间戳索引 MultilIndex 层级索引
ser_obj = pd.Series(range(5),index=list(range(5)))
print(type(ser_obj.index))
print(type(df_obj.index))
# 获取索引值
print(df_obj.index[2])
# 修改索引值 索引不可修改 TypeError: Index does not support mutable operations
# df_obj.index[0] = 2

import pandas as pd

# 构建series对象

ser_obj = pd.Series(range(5,10),index=['a','b','c','d','e'])

ser_obj.name = 'numbers'

ser_obj.index_name = 'index'

print(ser_obj)

# 根据索引取出数据

print(ser_obj['a'])

print(ser_obj[4])

# 切片,根据rangeindex切片不包括结束位置

print(ser_obj[1:3])

# 根据指定索引切片，包含结束位置

print(ser_obj['b':'d'])

# 不连续索引

print(ser_obj[[0,2,4]])

print(ser_obj[['a','c']])

# 布尔索引

import numpy as np

arr = np.array(range(10))

print(arr[arr>5])

bool_ser = ser_obj > 4

print(bool_ser)

print(ser_obj[bool_ser])

# 没有指定行索引和列索引，默认为RangeIndex

df_obj = pd.DataFrame(np.random.rand(4,5),columns=['A','B','C','D','E'])

print(df_obj['B'][1])

# 指定行索引

df_obj.index = ['a','b','c','d']

print(df_obj)

# 根据列索引取出一列数据，取出的是一个Series对象

print(type(df_obj['B']))

# 不连续索引,列索引

print(df_obj[['A','C']])

# 不能通过默认的rangeindex取出列数据
# print(df_obj[[0,2]])

# 切片

print(df_obj['a':'c'])

print(type(df_obj['a':'c']))

# 布尔索引
bool_df = df_obj > 0.5
print(bool_df)
# 根据布尔索引取出数据，并且不符合条件的数据自动填充为NaN,返回DataFrame对象
print(df_obj[bool_df])

ser_obj1 = pd.Series(range(10,20),index=range(10))
ser_obj2 = pd.Series(range(25,30),index=range(5))

print(ser_obj1)

print(ser_obj2)

ser_obj1 + ser_obj2

df_obj1 = pd.DataFrame(np.random.rand(2,2),columns=['a','b'])

df_obj2 = pd.DataFrame(np.random.rand(3,3),columns=['a','b','c'])

df_obj1+df_obj2

# add(要对齐运算的数据对象，对应位置默认值)对齐运算
# 对未对齐的数据填充，，然后进行运算

ser_obj1.add(ser_obj2,fill_value=0)

# 对未对齐的数据填充，然后进行运算

df_obj1.add(df_obj2,fill_value=0)

ser_obj3 = ser_obj1+ser_obj2

# 把空数据NaN替换为正常数据

# 返回一个替换后Series对象

ser_obj4 = ser_obj3.fillna(0,inplace=True)

print(ser_obj4)

df_obj3 = df.obj1+df_obj2

# inplace=True 就地替换，不返回结果，直接将df对象中的数据进行替换
# 替换-1或者False 表示非正常数据

df_obj3.fillna(-1,inplace=True)

# numpy中的函数  操作数据的函数

df_obj = pd.DataFrame(np.random.randn(4,5))

# 求绝对值 absolute
# 将函数应用到地方中的每一个元素

print(np.abs(df_obj))

ser = pd.Series(range(10))

# print(ser.max())
# apply() 函数 将某个函数应用到行数据或列数据
# 默认为0 是列轴向

f = lambda x:x.max()

print(df_obj.apply(f))

print(df_obj.apply(lambda x:x.min()))

# 指定轴向为行 axis参数指定轴向 0（列轴向） 1（行轴向）

print(df_obj)

print(df_obj.apply(lambda x:x.min().axis = 1))

# applymap() 将函数作用到df中的每一个元素上

print(df_obj.applymap(lambda x:abs(x)))

# 绝对值 保留小数点后2位

print(df_obj.applymap(lambda x:'%.2f'%abs(x)))

# 排序 sort_index 根据索引排序
ser_obj = pd.Series(range(10,15),index=np.random.randint(5,size=5))

print(ser_obj)

ser_obj.sort_index()

# sort_value 根据值排序

df = dp.DataFrame(np.random.randn(3,4),

    index=np.random.randint(3,size=3),

    columns=np.random.randint(4,size=4))

print(df)

# 不指定排序轴向，默认按照行索引排序
# ascending 排序规则
# axis=0 按照行排序 axis=1按照列  与上方情况相反

df.sort_index(ascending=False,axis=1)

# 按照值排序

# sort_value

df = pd.DataFrame(np.random.randn(3,4),index=range(1,4),columns=range(1,5))

# 按照值排序
# by 指定按照哪一列进行排序

print(df.sort_values(by=2,ascending=False))

# 指定按照多列进行排序 优先按照第一个指定的列进行排序

print(df.sort_values(by=[2,3]))

# fillna() 填充缺失数据的
# dropna() 丢弃缺失数据

df = pd.DataFrame([

np.random.randn(4),[1,2,np.nan,np.nan],[3,np.nan,np.nan,np.nan],['hello','world','test','qq']

])

# 获取布尔类型的索引，判断数据中哪些为空数据

print(df.isnull())

# df.fillna(1)
# dropna()丢弃缺失数据,默认按照行丢弃缺失数据，如果该行有NaN数据，则丢弃该行数据
# axis=0 按行丢弃  axis=1 按列丢弃空数据

df.dropna(axis=1)