数据分析---数据处理工具pandas（二）
2024-05-08 18:35:49
文章目录
- 数据分析---数据处理工具pandas（二）
- 一、Pandas数据结构Dataframe：基本概念及创建
- 1.DataFrame简介
- 2.创建Dataframe
- （1）方法一：由数组/list组成的字典
- （2）方法二：由Series组成的字典
- （3）方法三：通过二维数组直接创建
- （4）方法四：由字典组成的列表
- （5）方法五：由字典组成的字典
- （6）小结
- 二、Pandas数据结构Dataframe：索引
- 1.选择行与列
- 2.df.iloc[] 数字选择行
- 3.数据子集的获取
- 4.布尔型索引
- 5.多重索引
- 三、Pandas数据结构Dataframe：基本技巧
- 1.数据查看、转置
- 2.添加与修改
- 3.删除 del / drop() del语句 删除列 drop()删除行/列
- 4.对齐
- 5.排序1 - 按值排序 .sort_values
- 6.排序2 - 索引排序 .sort_index
数据分析—数据处理工具pandas（二）
一、Pandas数据结构Dataframe：基本概念及创建
1.DataFrame简介
Dataframe是一个表格型的数据结构，“带有标签的二维数组”。
Dataframe带有index（行标签）和columns（列标签）
DataFrame的每一列相当于一个Series,列名就是Series.name
eg:
import pandas as pd
import numpy as np
data = {'name': ['Mary', 'Jack'],'age': [12, 18],'sex': ['女', '男']
}
frame = pd.DataFrame(data)
print(frame)
print(frame.index) # 行标签
print(frame.columns) # 列标签
print(frame.values) # 查看值，为二维数组# 可以通过index column 更改行/列标签
frame.index = ['a', 'b'] # frame = pd.DataFrame(data, index=['a', 'b'])
print(frame)# 结果：name age sex
0 Mary 12 女
1 Jack 18 男
RangeIndex(start=0, stop=2, step=1)
Index(['name', 'age', 'sex'], dtype='object')
[['Mary' 12 '女']['Jack' 18 '男']]name age sex
a Mary 12 女
b Jack 18 男
2.创建Dataframe
（1）方法一：由数组/list组成的字典
# 由数组/list组成的字典 创建Dataframe，columns为字典key，index为默认数字标签data1 = {'name': ['Mary', 'Jack'],'age': [12, 18],'sex': ['女', '男']
}
frame1 = pd.DataFrame(data1)
print(frame1)
print('----')
data2 = {'one': np.arange(2), 'tow': np.arange(10, 12) # 注意列必须与前面保持一致，故nparange(10, 13) 有三个元素，不行，会运行错误
}
frame2 = pd.DataFrame(data2)
print(frame2)# columns参数：可以【重新指定】列的顺序，格式为list，如果现有数据中没有该列（比如'd'），则产生NaN值
d1 = pd.DataFrame(data1, columns=['sex', 'name', 'age', 'd']) # cpolumn只是改变已有的列顺序，不能改变成设置的列，但是index可以
print(d1)
# 如果columns重新指定时候，列的数量可以少于原数据,但是这样只会生成你指定的列
d2 = pd.DataFrame(data1, columns=['sex']) # 只会有sex这一列
print(d2)# index参数：重新定义index，格式为list，长度必须保持一致
d3 = pd.DataFrame(data1, index=['a', 'b'])
print(d3) # 结果：name age sex
0 Mary 12 女
1 Jack 18 男
----one tow
0 0 10
1 1 11sex name age d
0 女 Mary 12 NaN
1 男 Jack 18 NaNsex
0 女
1 男name age sex
a Mary 12 女
b Jack 18 男
小结：
1.用列表/数组组成的字典生成DataFrame必须保证value的长度一致
2.column只能用来重新只是改变已有的列顺序，不能改变成设置的列
（2）方法二：由Series组成的字典
# 由Seris组成的字典 创建Dataframe，columns为字典key，index为Series的标签（如果Series没有指定标签，则是默认数字标签）# 没有设置index的Series
data1 = {'one':pd.Series(np.random.rand(2)),'two':pd.Series(np.random.rand(3))
}
df1 = pd.DataFrame(data1)
print(df1)# 设置了Series的下标
data2 = {'one':pd.Series(np.arange(2), index=['a', 'b']),'two':pd.Series(np.arange(100, 103), index=['d', 'b', 'c'])
}
df2 = pd.DataFrame(data2)
print(df2)# 结果：one two
0 0.173666 0.578512
1 0.952062 0.601752
2 NaN 0.933093one two
a 0.0 NaN
b 1.0 101.0
c NaN 102.0
d NaN 100.0
小结：用Series生成DataFrame,其中Series的长度可以不一致。会取长的为行数，然后不足的用NaN补充
（3）方法三：通过二维数组直接创建
ar = np.arange(20, 30).reshape(2, 5)
print(ar)
f1 = pd.DataFrame(ar)
print(f1)
print('-----')
f2 = pd.DataFrame(ar, index=['a', 'b'], columns=list('qwert')) # column的元素个数必须与二维数组列数相同
print(f2)# 结果：
[[20 21 22 23 24][25 26 27 28 29]]0 1 2 3 4
0 20 21 22 23 24
1 25 26 27 28 29
-----q w e r t
a 20 21 22 23 24
b 25 26 27 28 29
（4）方法四：由字典组成的列表
d = [{'one': 1, 'two': 2}, {'one': 11, 'two': 12, 'three': 13}] # 列表中的每一个字典，相当于一行
f = pd.DataFrame(d, index=['a', 'b'])
print(f)# 结果：one three two
a 1 NaN 2
b 11 13.0 12
（5）方法五：由字典组成的字典
data = {'name':{'a':'Jack', 'b': 'Mary'},'sex':{'a': 18, 'b':19}
} # 相当于指定行标签
f = pd.DataFrame(data)
print(f)# 结果：name sex
a Jack 18
b Mary 19
（6）小结
# 1.
# 用字典的形式建立DataFrame，其column不能更改为你指定的值，只能更改已有列的顺序。
# 而用二维数组直接建立的可以用column更改默认的数字列标签。
# 可以这样理解，因为以字典的形式建立DataFrame其列名已经建立，就是字典的key,所以再用column只能更改顺序；用二维数组没有建立列名，是默认的数字标签，所以能改
# 2.
# 用字典Series形式建立DataFrame其column的值可以与列数不相同，其他的建立DataFrame其column的值与列数必须相同
# 3.
# 由数组/list组成的字典，由Series组成的字典，由字典组成的列表是指定了列名
# 由二维数组建立是行列名都为设置，是数字标签
# 由字典组成的字典是行列名都已经指定
二、Pandas数据结构Dataframe：索引
这个模块的主要知识有：选择列 / 选择行 / 切片 / 布尔判断
1.选择行与列
df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,index = ['one','two','three'],columns = ['a','b','c','d'])
print(df)
print('列----')
# 按照列名选择列，只选择一列输出Series，选择多列输出Dataframe
print(df.a) # 也可以用print(df['a'])，但是我个人建议如果是选择该列用前者，添加列用后者
print(df[['a', 'c']]) # 也可以用df.loc[:, ['a', 'c']]
print('-----')
print(df[:1]) # df[]中为数字时，默认选择行，且只能进行切片的选择，不能单独选择（df[0]）
# df[]默认选择列，[]中写列名（所以一般数据colunms都会单独制定，不会用默认数字列名，以免和index冲突）
print('行------')# 按照index选择行，只选择一行输出Series，选择多行输出Dataframe
print(df.loc['one']) # 不能用df['one'] df[]默认索引的是列
print(df.loc[['one', 'three']])# 结果：a b c d
one 11.744031 71.783455 54.043797 74.911762
two 25.748061 18.386051 23.297262 26.125503
three 98.138206 58.591411 57.216109 74.354878
列----
one 11.744031
two 25.748061
three 98.138206
Name: a, dtype: float64a c
one 11.744031 54.043797
two 25.748061 23.297262
three 98.138206 57.216109
-----a b c d
one 11.744031 71.783455 54.043797 74.911762
行------
a 11.744031
b 71.783455
c 54.043797
d 74.911762
Name: one, dtype: float64a b c d
one 11.744031 71.783455 54.043797 74.911762
three 98.138206 58.591411 57.216109 74.354878
小结：
df['列名']一般用于选择列df.loc[‘行名’]用于选择行df.loc['行名', '列名']来选择某一行某一列df[数字]中传入数字时，默认选择行，且只能进行切片的选择 【eg：df[:5]，不能单独选择df[0]（对行切片一般不使用该方法，该方法基本上不用）】
2.df.iloc[] 数字选择行
# df.iloc[] - 按照整数位置（从轴的0到length-1）选择行
# 类似list的索引，其顺序就是dataframe的整数位置，从0开始计df = pd.DataFrame(np.arange(16).reshape(4, 4),index=['one', 'two', 'three', 'four'],columns=['a', 'b', 'c', 'd']) # columns 记得加s
print(df)
# 单位置索引
print(df.iloc[0])
# 多位置索引
print(df.iloc[[2, 0]])
# 切片
print('切片----')
print(df.iloc[:-1]) # 末端不包含# 结果：a b c d
one 0 1 2 3
two 4 5 6 7
three 8 9 10 11
four 12 13 14 15
a 0
b 1
c 2
d 3
Name: one, dtype: int32a b c d
three 8 9 10 11
one 0 1 2 3
切片----a b c d
one 0 1 2 3
two 4 5 6 7
three 8 9 10 11
小结：
df.iloc[0]，表示选择第一行df.iloc[1:3]，切片，表示选择第二行与第三行。
3.数据子集的获取
（1）df.loc[] [] 左闭右闭 行标签/列标签
（2）df.iloc[] [) 左闭右开 数字索引
（3）df.ix[] 具有上面的两种功能：数字索引、行/列标签 数字是[) 行/列标签是[]
df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,index = ['one','two','three'],columns = ['a','b','c','d'])
print(df)
print(df.loc[:, ['a', 'c']])
print(df.iloc[0:2, 1:3])
print(df.ix[0:2, ['a', 'c']])# 结果：a b c d
one 63.666351 61.163233 31.822639 78.653631
two 49.693777 52.420641 42.267130 53.031000
three 44.693220 16.741017 11.834082 97.288596a c
one 63.666351 31.822639
two 49.693777 42.267130
three 44.693220 11.834082b c
one 61.163233 31.822639
two 52.420641 42.267130a c
one 63.666351 31.822639
two 49.693777 42.267130
4.布尔型索引
(1)布尔类型的行列共用
# 和Series原理相同
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['one','two','three','four'],columns = ['a','b','c','d'])
print(df)
print('------')
print(df>50)
print('------')
print(df[df>50])
# 行列的布尔类型类似，用df['one'] df.loc['a']等等# 结果：a b c d
one 17.212809 74.314714 10.156837 72.622754
two 88.294727 48.804259 31.103894 20.837973
three 95.101094 34.875227 78.032575 93.951124
four 94.727082 43.795659 86.518682 90.068478
------a b c d
one False True False True
two True False False False
three True False True True
four True False True True
------a b c d
one NaN 74.314714 NaN 72.622754
two 88.294727 NaN NaN NaN
three 95.101094 NaN 78.032575 93.951124
four 94.727082 NaN 86.518682 90.068478
(2)布尔类型的行与列
df = pd.DataFrame({'key1':np.arange(5),'key2':np.arange(5, 10),
}, index=list('abcde'))
print(df)
print('------')
s = pd.Series({'a':True, 'b':False, 'c':True, 'd':False, 'e':False})
print(df[s])s2 = pd.Series({'key1':True, 'key2':False})
print(s2)
print(df.columns[s2])# 结果：key1 key2
a 0 5
b 1 6
c 2 7
d 3 8
e 4 9
------key1 key2
a 0 5
c 2 7
key1 True
key2 False
dtype: bool
Index(['key1'], dtype='object')
5.多重索引
# 多重索引：比如同时索引行和列
# 先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['one','two','three','four'],columns = ['a','b','c','d'])
print(df)
print('------')print(df['a'].loc[['one','three']]) # 选择a列的one，three行# 结果：a b c d
one 73.315488 34.853760 22.059922 44.274220
two 7.484602 22.595569 32.362358 26.621247
three 21.273322 16.585421 48.346943 49.811086
four 79.518511 4.416195 29.054869 76.588620
------
one 73.315488
three 21.273322
Name: a, dtype: float64
三、Pandas数据结构Dataframe：基本技巧
这个模块的主要知识点有：数据查看、转置 / 添加、修改、删除值 / 对齐 / 排序
1.数据查看、转置
df = pd.DataFrame(np.random.rand(5, 2),columns=['a', 'b'])
print(df)
print(df.head(2)) # .head()查看头部数据,不带参数默认是5行
print(df.tail(2)) # .tail()查看尾部数据,不带参数默认是5行# 转置
print(df.T)# 结果：a b
0 0.178140 0.626120
1 0.875550 0.106871
2 0.051926 0.959511
3 0.770076 0.005052
4 0.846975 0.292112a b
0 0.17814 0.626120
1 0.87555 0.106871a b
3 0.770076 0.005052
4 0.846975 0.2921120 1 2 3 4
a 0.17814 0.875550 0.051926 0.770076 0.846975
b 0.62612 0.106871 0.959511 0.005052 0.292112
2.添加与修改
# 用df[]修改列 df.loc[]修改行 df[].loc[]修改某一元素值
df = pd.DataFrame(np.arange(20).reshape(4, 5),columns=list('abcde'))
print(df)# 修改元素值
df['a'].loc[0] = 100
print(df)# 添加元素值
print('添加-------')
df['f'] = 300
print(df)# 结果：a b c d e
0 0 1 2 3 4
1 5 6 7 8 9
2 10 11 12 13 14
3 15 16 17 18 19a b c d e
0 100 1 2 3 4
1 5 6 7 8 9
2 10 11 12 13 14
3 15 16 17 18 19
添加-------a b c d e f
0 100 1 2 3 4 300
1 5 6 7 8 9 300
2 10 11 12 13 14 300
3 15 16 17 18 19 300
3.删除 del / drop() del语句 删除列 drop()删除行/列
f = pd.DataFrame(np.arange(20).reshape(4, 5),columns=list('abcde'))
print(df)# del语句 - 删除列
del df['a'] # 使用del删除列，会删除df本身的数据，而是生成新的DataFrame
print(df)# drop()语句删除列
print(df.drop(['e'], axis=1)) # drop()删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据
# drop()删除行，inplace=False → 删除后生成新的数据，不改变原数据
print('删除行-----')
print(df.drop(0))
print(df.drop(1)) # 可以看到，使用drop()方法删除行/列都不是删除df本身的数据，而是生成新的DataFrame# 结果：a b c d e
0 0 1 2 3 4
1 5 6 7 8 9
2 10 11 12 13 14
3 15 16 17 18 19b c d e
0 1 2 3 4
1 6 7 8 9
2 11 12 13 14
3 16 17 18 19b c d
0 1 2 3
1 6 7 8
2 11 12 13
3 16 17 18
删除行-----b c d e
1 6 7 8 9
2 11 12 13 14
3 16 17 18 19b c d e
0 1 2 3 4
2 11 12 13 14
3 16 17 18 19
小结：
1.del和drop([], axis=1)用来删除列，drop()用来删除行
2.del会删除df本身的数据，而使用drop()方法删除行/列都不是删除df本身的数据，而是生成新的DataFrame
4.对齐
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对象之间的数据自动按照列和索引（行标签）对齐# 结果：A B C D
0 -0.286501 0.101564 0.934023 NaN
1 0.002405 -0.674116 -1.688925 NaN
2 -1.374691 0.188597 0.161464 NaN
3 -1.209863 -1.844409 -0.591461 NaN
4 -2.605153 -1.473555 1.891570 NaN
5 2.782283 1.193310 -1.139518 NaN
6 1.494297 1.553604 3.075171 NaN
7 NaN NaN NaN NaN
8 NaN NaN NaN NaN
9 NaN NaN NaN NaN
5.排序1 - 按值排序 .sort_values
# 同样适用于Series
df = pd.DataFrame(np.random.rand(4,4)*100,columns=['a', 'b', 'c', 'd'])
print(df)
# 单列排序
print(df.sort_values(['a'], ascending=False)) # ascending参数：设置升序降序，默认升序
print('多列排序------')
# 多列排序，按列顺序排序
print(df.sort_values(['a', 'd'])) # 先按a排序，如果a的值相同，则按d的值排序# 结果：a b c d
0 36.300085 90.999611 87.883077 39.251081
1 16.769310 99.653961 66.176705 10.763438
2 69.271539 94.620625 16.709941 95.833152
3 31.870412 92.897303 45.783337 43.051783a b c d
2 69.271539 94.620625 16.709941 95.833152
0 36.300085 90.999611 87.883077 39.251081
3 31.870412 92.897303 45.783337 43.051783
1 16.769310 99.653961 66.176705 10.763438
多列排序------a b c d
1 16.769310 99.653961 66.176705 10.763438
3 31.870412 92.897303 45.783337 43.051783
0 36.300085 90.999611 87.883077 39.251081
2 69.271539 94.620625 16.709941 95.833152
6.排序2 - 索引排序 .sort_index
# 与.sort_values类似
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'])
# 按照index排序
# 默认 ascending=True, inplace=False
print(df1)
print(df1.sort_index())
print(df2)
print(df2.sort_index())# 结果：a b c d
5 10.912363 66.069285 75.108926 50.976926
4 10.068745 89.445559 68.636782 56.758989
3 5.706953 17.755349 10.428633 31.123841
2 87.497426 76.308941 85.110218 97.168951a b c d
2 87.497426 76.308941 85.110218 97.168951
3 5.706953 17.755349 10.428633 31.123841
4 10.068745 89.445559 68.636782 56.758989
5 10.912363 66.069285 75.108926 50.976926a b c d
h 70.385483 10.462891 83.496788 82.744301
s 12.271862 25.484720 18.975885 25.769192
x 83.282964 58.578331 5.013539 12.543449
g 62.352057 18.190354 71.342096 28.424552a b c d
g 62.352057 18.190354 71.342096 28.424552
h 70.385483 10.462891 83.496788 82.744301
s 12.271862 25.484720 18.975885 25.769192
x 83.282964 58.578331 5.013539 12.543449
数据分析---数据处理工具pandas（二）相关推荐
- python 数据分析--数据处理工具Pandas(2)
数据处理模块--Pandas 4. Pandas处理字符串和日期数据 5. Pandas 数据清洗 5.1 重复观测处理 5.2 缺失值处理 5.2.1 删除法 5.2.2 替换法 5.3 异常值处理 ...
- Python 数据处理工具 Pandas（上）
序列与数据框的构造 外部数据的读取(文本文件读取.电子表格读取.数据库数据读取) 数据类型转换及描述统计 字符与日期数据的处理 数据清洗方法(重复观测处理.缺失值处理.异常值处理) 数据子集的获取 透 ...
- python数据处理工具-Pandas笔记
序列与数据框的构造 Pandas模块的核心操作对象就是序列Series和数据框DataFrame序列可以理解为数据集中的一个字段数据框是指含有至少两个字段(或序列)的数据集. 构造序列 可以通过以下几 ...
- python数据处理模块pandas_数据处理工具--Pandas模块
强大的数据处理模块Pandas,可以解决数据的预处理工作,如数据类型的转换.缺失值的处理.描述性统计分析和数据的汇总等 一.序列与数据框的构造 Pandas模块的核心操作对象为序列和数据框.序列指数据 ...
- Python数据处理工具 ——Pandas（数据的预处理）
0.前言 本文将介绍强大的数据处理模块Pandas,该模块可以帮助数据分析师轻松地解决数据的预处理问题,如数据类型的转换.缺失值的处理.描述性统计分析.数据的汇总等. 通过本章内容的学习,读者将会掌握 ...
- 第五章Python数据处理工具 ——Pandas
前言 上一章向读者介绍了有关数值计算的numpy模块,通过numpy模块可以非常方便地调用各种常用的数学和统计函数.本章将介绍强大的数据处理模块Pandas,该模块可以帮助数据分析师轻松地解决数据的预 ...
- python avg函数在哪个模块_python数据处理工具–Pandas模块
健壮的数据处理模块Pandas,能够处理数据的预处理作业,如数据类型的转化.缺失值的处理.描绘性核算分析和数据的汇总等 一.序列与数据框的结构 Pandas模块的中心操作政策为序列和数据框.序列指数据 ...
- Python数据处理工具——Pandas
目录 一.序列与数据框的构造 1.构造序列 2.构造数据框 二.外部数据的读取 1.文本文件的读取 2.电子表格的读取 pd.read_excel参数介绍: 三.数据类型转换及描述统计 四.字符与日期 ...
- 机器学习中常用的高级数据结构和数据分析包工具——pandas
https://www.toutiao.com/a6547880764996846087/ 现在有一个csv文件,内部数据为: 使用pandas.read_cvs来读取cvs文件数据,其中food_i ...
最新文章
- php集成paypal付款流程,在PHP中集成PayPal标准支付
- Dubbo 和 HSF 在阿里的实践：携手走向下一代云原生微服务
- 产品经理规划产品之需求梳理
- 华为《5G业务商业价值评估》白皮书！
- 从单体式架构迁移到微服务架构，妈妈再也不用担心我找工作了！
- malloc 就是返回开辟内存空间的首地址
- 华三服务器怎么设置系统启动模式,H3C 开局设置
- 女性自我的迷宫：看EMI的人体自拍
- 物联网应用：蓝牙模块在智能门锁中的应用
- openpyxl 读写 excel
- 启动redis闪退/失败
- Git 历史记录内容对比
- Android异常总结---1.异常原因: java.lang.IllegalArgumentException: URI: content://com.android.contacts/con
- linux常用指令学习记录
- 剑指offer面试题[35]-第一个只出现一次的字符
- 谷歌的诀窍：如何取消验证码
- Ubuntu命令整理
- Django 分页器 缓存 信号 序列化
- content='width=device-width, initial-scale=1.0'的解释
- C语言实现呼吸灯（HAL库）
热门文章
- 任正非 采访 安卓 鸿蒙,法媒专访任正非透露“鸿蒙”系统“很可能”快过安卓...
- django 导出数据到excel表 导出excel表到目标路径及客户端下载
- 华为暑期实习一面凉经
- Python数据分析初探项目 基于Python数据可视化的网易云音乐歌单分析系统 大学编程作业（TUST 天津科技大学 2022年）
- C语言ctime函数
- 用python编写一个篮球计分系统_毕业设计(3)基于MicroPython的篮球计时计分器模型的设计与实现...
- 教你怎么用c++基本语法实现一个简单的五子棋小游戏
- 高级查询（二）+php中文网,MySQL高级查询方法之记录查询
- KNIME 安装配置
- STM32硬件SPI控制TM1638 按键数码管LED显示模块