pandas学习笔记二：Dataframe

最新推荐文章于 2023-04-19 05:48:07 发布

周虽旧邦其命维新

最新推荐文章于 2023-04-19 05:48:07 发布

阅读量885

点赞数 1

分类专栏： python重点工具文章标签： pandas 学习 python

本文链接：https://blog.csdn.net/noob9527/article/details/127285187

版权

python重点工具专栏收录该内容

9 篇文章 2 订阅

订阅专栏

1、dataframe基本概念及创建

import numpy as np
import pandas as pd

# Dataframe 数据结构
# DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。
# DataFrame 既有index（行标签）也有columns（列标签），它可以被看做由 Series 组成的字典（共同用一个索引）。

data = {'name':['Jack','Tom','Mary'],
        'age':[18,19,20],
       'gender':['m','m','w']}
d = pd.DataFrame(data)
print(d)
print(type(d))
print(d.index, '\n数据类型：', type(d.index))
print(d.columns, '\n数据类型：', type(d.columns))
print(d.values, '\n数据类型：', type(d.values))
# 查看数据，数据类型为dataframe
# .index查看行标签
# .columns查看列标签
# .values查看值，数据类型为ndarray
print('-------------------------------------------------')

# Dataframe 创建方法一：由数组/list组成的字典
# 创建方法:pandas.Dataframe()

data1 = {'a':[1,2,3],
        'b':[3,4,5],
        'c':[5,6,7]}
data2 = {'one':np.random.rand(3),
        'two':np.random.rand(3)}   # 这里如果'two':np.random.rand(4)
                                   # 会报错ValueError: All arrays must be of the same length

print(data1)
print(data2)
d1 = pd.DataFrame(data1)
d2 = pd.DataFrame(data2)
print(d1)
print(d2)
# 由数组/list组成的字典 创建Dataframe，columns为字典key，index为默认数字标签
# 字典的值的长度必须保持一致！

d1 = pd.DataFrame(data1, columns=['b', 'd', 'a', 'c'])
print(d1)
d1 = pd.DataFrame(data1, columns=['b', 'd'])
print(d1)
# columns参数：可以重新指定列的顺序，格式为list，如果现有数据中没有该列（比如'd'），则产生NaN值
# 且columns列的数量可以少于原数据

d1 = pd.DataFrame(data1, index=[3, 1, 2])
# 这里如果尝试 index = [3, 1, 2, 0] 会报错ValueError: Length of values (3) does not match length of index (4)
print(d1)
# index参数：重新定义index，格式为list，长度必须保持一致

# Dataframe 创建方法二：由Series组成的字典
data1 = {'one':pd.Series(np.random.rand(2)),'two':pd.Series(np.random.rand(3))}
data2 = {'one':pd.Series(np.random.rand(2), index=['a', 'b']),
         'two':pd.Series(np.random.rand(3), index=['a', 'b', 'c'])}
print(data1)
print(data2)
d1 = pd.DataFrame(data1)
print(d1)
d2 = pd.DataFrame(data2)
print(d2)
# 由Seris组成的字典 创建Dataframe，columns为字典key，index为Series的标签（如果Series没有指定标签，则是默认数字标签）
# Series可以长度不一样，生成的Dataframe会出现NaN值

# Dataframe 创建方法三：通过二维数组直接创建

arr = np.random.rand(9).reshape(3, 3)
print(arr)
d = pd.DataFrame(arr)
print(d)
d = pd.DataFrame(arr, columns=['name', 'age', 'gender'], index=['1', '2', '3'])
# index或columns长度不等于已有数组则报错ValueError: Shape of passed values is (3, 3), indices imply (xx,xx)
print(d)
# 通过二维数组直接创建Dataframe，得到一样形状的结果数据，如果不指定index和columns，两者均返回默认数字格式
# index和colunms指定长度与原数组保持一致

# Dataframe 创建方法四：由字典组成的列表

data = [{'one': 1, 'two': 2}, {'one': 5, 'two': 10, 'three': 20}]
print(data)
d = pd.DataFrame(data)
print(d)
d = pd.DataFrame(data, index=['a', 'b'])
print(d)
d = pd.DataFrame(data, columns=['one', 'two', 'four'])
print(d)
# 由字典组成的列表创建Dataframe，columns为字典的key，index不做指定则为默认数组标签
# colunms和index参数分别重新指定相应列及行标签


# Dataframe 创建方法五：由字典组成的字典

data = {'Jack':{'math':90,'english':89,'art':78},
       'Marry':{'math':82,'english':95,'art':92},
       'Tom':{'math':78,'english':67}}
d = pd.DataFrame(data)
print(d)
# 由字典组成的字典创建Dataframe，columns为字典的key，index为子字典的key

d = pd.DataFrame(data, index=['a', 'b', 'c'])
print(d)
d = pd.DataFrame(data, columns=['David', 'Tom', 'Marry'])
print(d)
# columns参数可以增加和减少现有列，如出现新的列，值为NaN
# index在这里和之前不同，并不能改变原有index，如果指向新的标签，值为NaN （非常重要！）

2、dataframe基本概念及创建作业

import numpy as np
import pandas as pd

# 作业1：用四种不同的方法，创建以下Dataframe（保证columns和index一致，值不做要求）

# 1.列表组成字典
data = {'four':np.arange(5),
       'one':np.arange(5),
       'three':np.arange(5),
       'two':np.arange(5)}
s = pd.DataFrame(data, index=list('abcde'))
print(s)

# 2.Series组成字典
data = {'four':pd.Series(np.arange(5), index=list('abcde')),
       'one':pd.Series(np.arange(5), index=list('abcde')),
       'three':pd.Series(np.arange(5), index=list('abcde')),
       'two':pd.Series(np.arange(5), index=list('abcde'))}
s = pd.DataFrame(data)
print(s)

# 3.二维数组创建DataFrame

data = np.arange(20).reshape(5, 4)
# print(data)
s = pd.DataFrame(data, index=list('abcde'), columns=['four', 'one', 'three', 'two'])
print(s)

# 4.字典组成的数组
data = [{'four': 2, 'one': 3, 'three': 4, 'two': 1},
        {'four': 12, 'one': 13, 'three': 14, 'two': 11},
        {'four': 2, 'one': 3, 'three': 4, 'two': 1},
        {'four': 2, 'one': 3, 'three': 4, 'two': 1},
        {'four': 2, 'one': 3, 'three': 4, 'two': 1}]
s = pd.DataFrame(data, index=list('abcde'))
print(s)

# 5.由字典组成的字典

data = {'four':{'a': 1, 'b': 2, 'c': 4, 'd': 3, 'e':5},
        'one':{'a': 1, 'b': 2, 'c': 4, 'd': 3, 'e':5},
        'three':{'a': 11, 'b': 12, 'c': 14, 'd': 3, 'e':5},
        'two':{'a': 1, 'b': 2, 'c': 4, 'd': 3, 'e':5}}
s = pd.DataFrame(data)
print(s)

3、dataframe索引

import numpy as np
import pandas as pd

# 选择行与列

s = pd.DataFrame(np.random.rand(12).reshape(3,4)* 100, index=list('abc'), columns=list('xyzo'))
print(s)
d1 = s['x']
print(d1, type(d1))
d2 = s[['y', 'o']]
print(d2, type(d2))
# 按照列名选择列，只选择一列输出Series，选择多列输出Dataframe

d1 = s.loc['a']
d2 = s.loc[['a', 'c']]
print(d1, type(d1))
print(d2, type(d2))
print('-------------------------')
print(s.loc)
# d[]默认选择列，[]中写列名（所以一般数据colunms都会单独制定，不会用默认数字列名，以免和index冲突）
# 单选列为Series，print结果为Series格式
# 多选列为Dataframe，print结果为Dataframe格式

s = pd.DataFrame(np.random.rand(12).reshape(3,4)* 100, index=list('abc'), columns=list('xyzo'))
s2 = pd.DataFrame(np.random.rand(12).reshape(3,4)* 100, columns=list('xyzo'))
print(s2)
d3 = s[:1]
print(d3)
# d[]中为数字时，默认选择行，且只能进行切片的选择，不能单独选择（d[0]）
# 输出结果为Dataframe，即便只选择一行
# d[]不能通过索引标签名来选择行(d['one'])

# 核心笔记：d[col]一般用于选择列，[]中写列名
d = s.loc['a']
print(d)
d = s2.loc[1]
print(d)
# 单个标签索引，返回Series

print('==============================')
d = s.loc['a':'c']
print(d)
d = s2.loc[0:2]
print(d)
# 可以做切片对象
# 末端包含

# 核心笔记：d.loc[label]主要针对index选择行，同时支持指定index，及默认数字index
# df.loc() : Selection by Label 函数，即为按标签取数据
# df.iloc() : Selection by Position 函数，即按位置选择数据，只接受整型参数

# d.iloc[] - 按照整数位置（从轴的0到length-1）选择行
# 类似list的索引，其顺序就是dataframe的整数位置，从0开始计

print('----------------------------------------')
d = s2.iloc[1]
print(d)
d = s2.iloc[-1]
print(d)
# 单位置索引
# 和loc索引不同，不能索引超出数据行数的整数位置

print('=============================================')
d = s2.iloc[[1, 0]]
print(d)
# 多位置索引
# 顺序可变

d = s2.iloc[0:1]
print(d)
# 切片索引
# 末端不包含

# 布尔型索引
# 和Series原理相同

print('------------------------------------------------------')
d = pd.DataFrame(np.random.rand(16).reshape(4, 4) * 100, index=['one','two','three','four'], columns=['a','b','c','d'])
print(d)
b1 = d > 50
print(d[b1])
# 不做索引则会对数据每个值进行判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN

b1 = d['a'] < 20
print(b1, type(b1))
print(d[b1])
# 单列做判断
# 索引结果保留 单列判断为True的行数据，包括其他列

b1 = d[['a', 'b']] > 50
print(b1)
print(d[b1])
# 多列做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN

b1 = d.loc[['one', 'three']] < 40
print(b1)
print(d[b1])
# 多行做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN

# 多重索引：比如同时索引行和列
# 先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量

d = pd.DataFrame(np.random.rand(16).reshape(4, 4) * 100, index=['one','two','three','four'], columns=['a','b','c','d'])
print(d)
# print(d['a'], type(d['a']))
print(d['a'].loc[['one', 'four']])  # 选择a列的one，three行
print(d[['b', 'c', 'd']].iloc[:2])  # 选择b，c，d列的前两行数据
print(d[d > 50].iloc[::2])          # 选择满足判断索引的one，three行

4、dataframe索引作业

import numpy as np
import pandas as pd

# 作业1：如图创建Dataframe(4*4，值为0-100的随机数)，通过索引得到以下值
# ① 索引得到b，c列的所有值
# ② 索引得到第三第四行的数据
# ③ 按顺序索引得到two，one行的值
# ④ 索引得到大于50的值

d = pd.DataFrame(np.random.rand(16).reshape(4,4) * 100, index=['one', 'two', 'three', 'four'], columns=list('abcd'))
print(d)
print(d[['b', 'c']])
print(d.loc[['three', 'four']])
print(d.iloc[[2, 3]])
print(d.iloc[2:4])
print(d.loc[['two', 'one']])
print(d[d>50])

5、dataframe基本技巧

import numpy as np
import pandas as pd

# 数据查看、转置

d = pd.DataFrame(np.random.rand(16).reshape(8, 2), columns=['a', 'b'])
print(d)
print(d.head(2))
print(d.tail(1))
print(d.T)
# .head()查看头部数据
# .tail()查看尾部数据
# 默认查看5条
# .T 转置

# 添加与修改

d['c'] = 100
print(d)
d.loc[8] = 30
print(d)
# 新增列/行并赋值
d['c'] = 20
print(d)
d.loc[[1, 8]] = 40
print(d)
# 索引后直接修改值

del d['c']
print(d)
# del语句 - 删除列 直接修改原数据

print(d.drop(8))
print(d.drop([7, 6]))
# drop()删除行，inplace=False → 删除后生成新的数据，不改变原数据

print(d.drop('a', axis=1))
# drop()删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据

# 对齐

df1 = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C'])
print(df1 + df2)
# DataFrame对象之间的数据自动按照列和索引（行标签）对齐

# 排序1 - 按值排序 .sort_values
# 同样适用于Series

d = pd.DataFrame(np.random.randn(4,4) * 100, columns=list('abcd'))
print(d)
print(d.sort_values('a', ascending=True))
print(d.sort_values('b', ascending=False))
# ascending参数：设置升序降序，默认升序
# 单列排序

d = pd.DataFrame({'a':[1,1,1,1,2,2,2,2],
                  'b':list(range(8)),
                  'c':list(range(8,0,-1))})
print(d.sort_values(['a','c']))
print('--------------------------------------')
# 多列排序，按列顺序排序

# 排序2 - 索引排序 .sort_index

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = [5,4,3,2],
                   columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = ['h','s','x','g'],
                   columns = ['a','b','c','d'])
print(df1)
print(df1.sort_index())
print(df2)
print(df2.sort_index())
# 按照index排序
# 默认 ascending=True, inplace=False

6、dataframe基本技巧作业

import numpy as np
import pandas as pd

# 作业1：创建一个3*3，值在0-100区间随机值的Dataframe（如图），分别按照index和第二列值大小，降序排序

d = pd.DataFrame(np.random.rand(9).reshape(3, 3) * 100, index=list('abc'), columns=['v1', 'v2', 'v3'])
print(d)
print(d.sort_index(ascending=False))
print(d.sort_values('v2', ascending=False))

# 作业2：创建一个5*2，值在0-100区间随机值的Dataframe（如图）df1，通过修改得到df2

d = pd.DataFrame(np.random.rand(10).reshape(5, 2) * 100, index=list('abcde'), columns=['v1', 'v2'])
print(d)
d2 = d.T
del d2['e']
print(d2)