第十三阶段 -- 数据分析05：pandas

最新推荐文章于 2024-08-04 22:25:12 发布
最新推荐文章于 2024-08-04 22:25:12 发布
阅读量562 收藏
点赞数
分类专栏： python学习 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42375099/article/details/98105392
版权

文章目录

1.Pandas

Pandas库基于Numpy库，提供很多用于数据操作与分析功能

1.1. 安装与使用

安装：
pip install pandas | conda install pandas
使用：
import pandas as pd

1.2. 两个常用数据类型

pandas提供两个常用数据类型

  1. Series：一维的，带标签的数组对象

  2. DataFrame：二维的，带标签的数组对象

import pandas as pd
import numpy as np

2. Series 类型

Series类型类似numpy的一维数组，可将此类型看做一组数据与数据相关标签(索引)联合构成。

创建方式：

  1. 列表等可迭代对象

  2. ndarray 数组对象

  3. 字典对象

  4. 标量

# Series 带标签的一维数组
# 1.使用列表创建
# s = pd.Series([1,2,3])

# 2.使用可迭代对象
# s=pd.Series(range(5))

# 3.ndarray数组对象
# s=pd.Series(np.array([1,2,3]))

# 4.字典数据，Series对象的标签为字典数据中key
# s=pd.Series({'a':1,'b':2,'c':3})

# 5.标量,使用index参数指定索引
s=pd.Series(33,index=['a','b','c'])
display(s)
2.1. 相关属性
  • index
  • values
  • shape
  • size
  • dtype
  • name

说明：

  1. Series 对象可以通过 index 与 values 访问索引与值。

  2. 如果没有指定索引，则会自动生成从0开始后的整数值索引，也可以使用index显式指定索引。

  3. Series 对象与属性 index 同样有 name 属性，Series 的 name 属性可在创建时通过 name 参数指定。

  4. 当数值较多时，可以通过 head 和 tail 访问前后N个数据。

  5. Sereis 对象的数组只能是一维数组类型。

# s = pd.Series([1,2,3])
s = pd.Series([1,2,3],index=list('abc'))
# 返回元素索引
display(s.index)
# 返回元素的值
display(s.values,type(s.values))
# 返回元素的形状
display(s.shape)
# 返回元素个数
display(s.size)
# 返回元素数据类型
display(s.dtype)

# output:
Index(['a', 'b', 'c'], dtype='object')
array([1, 2, 3], dtype=int64)
numpy.ndarray
(3,)
3
dtype('int64')
  • Series 对象与 index 同样有 name 属性，Series 的 name 属性可在创建时通过 name 参数指定
# Series 对象与 index 同样有 name 属性，Series 的 name 属性可在创建时通过 name 参数指定
s = pd.Series([1,2,3],index=list('abc'))
s.name='Sereis name'
s.index.name='index name'
display(s)

# output:
index name
a    1
b    2
c    3
Name: Sereis name, dtype: int64

ind = pd.Index(['a','b','c'],name='index name')
s = pd.Series([1,2,3],index=ind,name='Series name')
display(s)

# output:
index name
a    1
b    2
c    3
Name: Series name, dtype: int64
  • 当数值较多时，可以通过 head 和 tail 访问前后N个数据
# 当数值较多时，可以通过 head 和 tail 访问前后N个数据
s = pd.Series(np.arange(1000))
# head 查看前面数据，默认5条；tail 查看后面的数据，默认是5条
# display(s.head(),s.tail())
display(s.head(3),s.tail(3))

# output:
0    0
1    1
2    2
dtype: int32
997    997
998    998
999    999
dtype: int32

# 只能传入一维数据；报错！
s = pd.Series(np.array([[1,2],[2,3]]))
s
2.1.1. Series 和 ndarray 索引访问比较

区别：Series 对象可以看做带标签的 ndarray，其中标签和值类似字典的 key 和 value，不支持负数

s = pd.Series([1,2,3])
# display(s)
# display(s[0])
# Series类似于字典的key和value方式，不支持负数访问
# display(s[-1])

# ndarray类似于list索引，支持负数访问
x = np.array([1,2,3])
display(x[-1])

#output:
3
2.1.2. Series 相关操作

Sereis在操作上与ndarray类似：

  1. 支持广播与向量化运算

  2. 支持索引与切片

  3. 支持整数数组与布尔数组提取元素

运算：

Numpy统计函数也适用于Sereis类型，例如 np.mean，np.sum等。多个Sereis运算时，会根据索引进行对齐。当索引无法匹配时，结果值为NaN(缺失值)。

说明：

  1. pandas或Sereis的isnull与notnull判断数据是否缺失

  2. Sereis对象可以使用运算符运算，也可以使用Sereis对象提供相关方法进行运算（指定缺失值的填充值）

  3. Sereis和Numpy对于空值（NaN）计算方式上不同。Numpy会处理 NaN，而Sereis忽略 NaN

# Series和ndarray类似，也支持广播和向量化整体操作
s = pd.Series([1,2,3])
s2 = pd.Series([2,3,4])
# display(s*s2)
display(s*2)

# output:
0    2
1    4
2    6
dtype: int64
  • Series运算时候，根据标签进行匹配，如果是不一致，产生空值；空值和任何其他的值运算还是空值。
s = pd.Series([1,2,3],index=[1,2,3])
s2 = pd.Series([2,3,4],index=[2,3,4])
# Series运算时候，根据标签进行匹配，如果是不一致，产生空值
display(s*s2)

# output:
1    NaN
2    4.0
3    9.0
4    NaN
dtype: float64

# 空值和任何其他的值运算还是空值  np.nan/3=nan
np.nan/3

# output:
nan
  • 如果 Series 对象运算结果不想要空值，可以使用 Sereis 对象提供计算方法得到
s = pd.Series([1,2,3],index=[1,2,3])
s2 = pd.Series([2,3,4],index=[2,3,4])
# 如果Series对象运算结果不想要空值，可以使用Sereis对象提供计算方法得到
s.add(s2,fill_value=10)

# output:
1    11.0
2     4.0
3     6.0
4    14.0
dtype: float64
  • 判断数据是否为空值
s = pd.Series([1, 2, 3, float('NaN'), np.nan])
# 1.判断数据是否为空值
# display(s.isnull())

# 2.判断数据不是为空值
# display(s.notnull())
display(pd.notnull(s))

# output:
0     True
1     True
2     True
3    False
4    False
dtype: bool
  • 在统计函数中，numpy 处理 NaN；Sereis 忽略 Nan
# 在统计函数中，numpy处理NaN,Sereis忽略Nan
a = np.array([1,2,3,np.nan])
s = pd.Series([1,2,3,np.nan])
display(np.mean(a))
display(np.mean(s))

# output:
nan
2.0
2.2. 索引
2.2.1. 标签索引与位置索引

当Sereis对象的index值为非数值类型，可以使用标签和位置索引，也可以显式指定标签或者位置索引访问

  • loc：标签索引访问
  • iloc：位置索引访问
2.2.2. 标签、位置数组索引与布尔数组索引

Sereis支持标签、位置数组索引与布尔数组索引，返回是原数据的拷贝

# s = pd.Series([1,2,3])
# display(s[0])
# 通过index指定标签信息，非数值类型标签信息
# Sereis对象既可以通过标签索引来访问，也可以通过位置索引来访问
s = pd.Series([1,2,3],index=list('abc'))
display(s['a'])
display(s[0])

# output:
1
1
  • 通过index指定标签信息，数值类型标签信息；当指定索引是数值类型时候，位置索引失效
# 通过index指定标签信息，数值类型标签信息
# 当指定索引是数值类型时候，位置索引失效
s = pd.Series([1,2,3],index=[2,3,4])
display(s[2])
# 错误
# display(s[0])

# output:
1
  • Sereis对象提供 iloc 和 loc 来显式访问位置和标签索引
# Sereis对象提供iloc和loc来显式访问位置和标签索引
s = pd.Series([1,2,3],index=list('abc'))
# loc 专门来通过标签进行访问
display(s.loc['a'])
# iloc 专门来通过位置进行访问
display(s.iloc[0])

# output:
1
1
  • 我们通过标签或位置数组来访问多个元素
# 我们通过标签或位置数组来访问多个元素
s = pd.Series([1,2,3],index=list('abc'))
display(s.loc['a'])
display(s.loc[['a','c']])
display(s.iloc[[0,2]])

# output:
1
a    1
c    3
dtype: int64

a    1
c    3
dtype: int64
  • 通过标签或位置数组来访问多个元素得到是原数据拷贝，彼此间不会互相干扰
# 通过标签或位置数组来访问多个元素得到是原数据拷贝，彼此间不会互相干扰
s = pd.Series([1,2,3],index=list('abc'))
s2 = s.loc[['a','c']]
display(s,s2)
s2['a']=100
display(s,s2)

# output:
a    1
b    2
c    3
dtype: int64

a    1
c    3
dtype: int64

a    1
b    2
c    3
dtype: int64

a    100
c      3
dtype: int64
  • 布尔数组索引访问Sereis中数据
# 布尔数组索引访问Sereis中数据
s = pd.Series([1,2,3,4],index=list('abcd'))
display(s>2)
display(s[s>2])

# output:
a    False
b    False
c     True
d     True
dtype: bool

c    3
d    4
dtype: int64
2.3. 切片

Series 和 ndarray 数组一样支持切片访问多个元素，返回的数据和原数据共享内存。

# Series对象和ndarray数组一样支持切片操作，且返回的数据和原数据共享内存
s = pd.Series([1,2,3,4])
s2 = s[0:3]
display(s2)
# 共享内存，修改其中一方会影响另外一方
s2[0] = 100
display(s2,s)

# output:
0    1
1    2
2    3
dtype: int64

0    100
1      2
2      3
dtype: int64

0    100
1      2
2      3
3      4
dtype: int64
  • Sereis 具有 标签索引和位置索引，通过连着访问多个数据：
    1. 位置索引切片访问，不包含终止值
    2. 标签索引切片访问，包含终止值
# Sereis具有标签索引和位置索引，通过连着访问多个数据
s = pd.Series([1,2,3,4],index=list('abcd'))
# 位置索引切片访问，不包含终止值
display(s.iloc[0:3])
# 标签索引切片访问，包含终止值
display(s.loc['a':'d'])

# output:
a    1
b    2
c    3
dtype: int64

a    1
b    2
c    3
d    4
dtype: int64
2. 4. Series 增删改查操作

  1. 增加值 / 删除值，类似字典操作。

  2. 删除值，drop；inplace 为 false，根据原有的Series对象数据复制得到新的Sereis，对新的Sereis对象删除数据并将其返回，而原有的对象没有被执行删除操作！

    inplace 为 True，删除的就是原有 Sereis 对象的数据，并且 drop 方法返回 None。

  3. 删除多个值：drop

s = pd.Series([1,2,3,4],index=list('abcd'))
# 获取值，通过标签或者位置索引（或者2者数组）
display(s.loc['a'])
display(s.iloc[0])
# 修改值
s.loc['a']=100

# 增加值，类似字典操作
s['f']=5
display(s)
# 删除值，类似字典操作
# del s['f']
# display(s)

# 删除值，drop,inplace为false
# inplace为false，根据原有的Series对象数据复制得到新的Sereis，对新的Sereis对象删除数据并将其返回
# s2 = s.drop('f')
# display(s,s2)

# inplace为True，删除的就是原有Sereis对象的数据，并且drop方法返回None
# s2 = s.drop('f',inplace=True)
# display(s,s2)

# 删除多个值，drop
s.drop(['a','f'],inplace=True)
display(s)

# output:
1
1
a    100
b      2
c      3
d      4
f      5
dtype: int64

b    2
c    3
d    4
dtype: int64

5. DataFrame

  1. DataFrame 类似数据库中数据表，多列构成，每列类型不同。
  2. DataFrame 二维数据类型，具有行,列索引。
  3. DataFrame 从每一列来看，是一个Series对象；从每一行来看，也是一个Sereis对象
5.1. DataFrame 创建

我们可以使用如下方式创建 DataFrame：

  1. 二维数据结构类型（列表，ndarray数组，DataFrame等）

  2. 字典类型，key 列名，value 为一维数组结构（列表，ndarray数组，Sereis等）

# 1.使用二维的数据结构类型(ndarray,列表)
# df = pd.DataFrame(np.array([[100,100,100],[90,90,90],[80,80,80]]))
# df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]])
# # print(df)
# display(df) # 相比较print()，display()有更好的输出结果

# 2.使用字典创建，key就是列名，value一维数据结构
df = pd.DataFrame({'语文':[100,100,100],'数学':[90,90,90],'外语':[80,80,80]})
display(df)

# output:
	语文	数学	外语
0	100	90	80
1	100	90	80
2	100	90	80
  • 未通过 index、columns 指定行索引和列索引，行索引和列索引默认从0开始。
  • index 指定行索引
# 未通过index、columns指定行索引和列索引，行索引和列索引默认从0开始
# index指定行索引
df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80
5.2. DataFrame 属性

  1. index

  2. columns

  3. values

  4. shape

  5. ndim

  6. dtypes

  7. index.name / columns.name

df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
# 返回行索引
display(df.index)
# 返回列索引
display(df.columns)
# 返回DataFrame对象对应ndarray数组
display(df.values)
# 返回形状：返回三行三列
display(df.shape)
# 返回维度
display(df.ndim)
# 返回各列数据类型
display(df.dtypes)

# 通过index修改行索引信息
# df.index=['张三2','李四2','王五2']
# display(df)

# 设置行索引和列索引名称
df.index.name='index-name'
df.columns.name='columns-name'
display(df)

# 超过二维数据创建DataFrame；报错！
df = pd.DataFrame(np.arange(18).reshape(2,3,3))
display(df)

# output:
Index(['张三', '李四', '王五'], dtype='object')
Index(['语文', '数学', '外语'], dtype='object')
array([[100, 100, 100],
       [ 90,  90,  90],
       [ 80,  80,  80]], dtype=int64)
       
(3, 3)

2

语文    int64
数学    int64
外语    int64
dtype: object

columns-name	语文	数学	外语
  index-name			
			张三	100	100	100
			李四	90	90	90
			王五	80	80	80
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
*
*
*
ValueError: Must pass 2-d input
5.3. DataFrame 列操作

  1. 获取列数据：

    • df[列索引]

    • df.列索引（不推荐）

  2. 增加（修改）列：df[列索引] = 列数据

  3. 删除列：

    • del.df[列索引]

    • df.pop(列索引)

    • df.drop(列索引或数组)

df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)
# 获取列数据，通过df[列索引]
# 注意，此种方式索引被解析成列索引，获取列数据，不会解析成行索引
# display(df['语文'],type(df['语文']))

# 获取多列数据，df[索引数组]
display(df[['语文','数学']],type(df[['语文','数学']]))
# 如果索引数组中索引只有一个列标签，返回的仍然是DataFrame类型
display(df[['语文']],type(df[['语文']]))

# 第二种方式访问列数据，不推荐
display(df.语文)

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80

	语文	数学
张三	100	100
李四	90	90
王五	80	80
pandas.core.frame.DataFrame

	语文
张三	100
李四	90
王五	80
pandas.core.frame.DataFrame

张三    100
李四     90
王五     80
Name: 语文, dtype: int64
  • 增加、修改列：列标签不存在话，增加一列；根据已有列计算，得到新的一列；列标签存在话，修改一列。
df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)
# 增加、修改列
# 列标签不存在话，增加一列
# df['物理']=[80,80,80]
# display(df)

# 列标签存在话，修改一列
# df['语文']=[80,80,80]
# display(df)

# 根据已有列计算，得到新的一列
df['总分']=df['语文']+df['数学']+df['外语']
display(df)

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80

语文	数学	外语	总分
张三	100	100	100	300
李四	90	90	90	270
王五	80	80	80	240
  • 删除列，采用类似字典方式 ：del 和 pop，或者 drop
df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)
# 删除列，采用类似字典方式：del和pop
# del df['语文']
# display(df.pop('语文'))
# display(df)

# DaraFrame提供drop方法删除,
df.drop('数学',axis=1,inplace=True)
display(df)

# output:
语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80

	语文	外语
张三	100	100
李四	90	90
王五	80	80
5.4. DataFrame 行操作

  1. 获取行：

    • df.loc：根据标签进行索引

    • df.iloc：根据位置进行索引

  2. 增加行：append

  3. 删除行：df.drop

df = pd.DataFrame([[100,100,100],[90,90,90],[80,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

# df.loc：标签索引
display(df.loc['张三'],type(df.loc['张三']))
# df.iloc：位置索引
# display(df.iloc[0])

# 多行获取
# display(df.loc[['张三','李四']])

# 增加行数据
# 创建一个Sereis对象，Sereis对象通过append方法加入到DataFrame中
# Sereis对象包含：value信息，index信息，name信息
newLine= pd.Series([85,85,85],index=['语文','数学','外语'],name='赵六')
df = df.append(newLine)
display(df)

# 删除行数据
df.drop(['张三','李四'],axis=0,inplace=True)
display(df)


# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80

语文    100
数学    100
外语    100
Name: 张三, dtype: int64

pandas.core.series.Series

	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	80	80	80
赵六	85	85	85

	语文	数学	外语
王五	80	80	80
赵六	85	85	85
5.5. DataFrame混合操作
  • 先获取行，再获取列
  • 先获取列，再获取行
df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

		### 1.先获取行，再获取列 ###
# display(df.loc['张三'].loc['语文'])
# display(df.loc['张三']['语文'])
# display(df.loc['张三','语文'])

		### 2.先获取列，再获取行 ###
display(df['语文'].loc['张三'])
display(df['语文']['张三'])

		### 错误，不支持 ###
# display(df['语文','张三'])

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	86	80	80

100

100
5.6. DataFrame结构

DataFrame的一行或一列，都是Sereis类型对象。对于行来说，Series对象name 值就是行索引名称，元素值对应标签是列索引名称。对于列来说，Series对象 name 值就是列索引名称，元素值对应标签是行索引名称。

df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

# display(df.loc['张三'],type(df.loc['张三']))
display(df['语文'],type(df['语文']))


# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	86	80	80

张三    100
李四     90
王五     86
Name: 语文, dtype: int64

pandas.core.series.Series
5.7. DataFrame 切片、布尔、标签数组索引
  • df[切片]：对行操作；df[索引]：对列操作
  • 布尔数组是对行操作
  • 标签数组是对列操作
df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

		### 1.混合操作，列确定，对行切片 ###
# display(df['语文'].loc['张三':'李四'])
# display(df['语文'].iloc[0:1])

		### 2.混合操作，行确定，对列切片 ###
# display(df.loc['张三'].loc['语文':'数学'])
# display(df.loc['张三'].iloc[0:1])

		### 3.混合操作，对行切片，对列切片 ###
# display(df.loc['张三':'李四'])
# display(df.loc['张三':'李四'].loc['语文':'数学']) # 对行操作完成后，又对行进行操作！所以没有结果!
# display(df.loc['张三':'李四','语文':'数学'])

		### 4.仅对行进行切片操作 ###
# display(df.loc['张三':'李四'])
# display(df.iloc[0:1])

		### 5.仅对列进行切片操作 ###
# display(df['语文':'数学']) # 不支持这种操作！
display(df.loc[:,'语文':'数学'])

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	86	80	80

	语文	数学
张三	100	100
李四	90	90
王五	86	80
  • 一维布尔数组，对行进行操作，不是对列进行操作；二维布尔数组，对DataFrame的每一个元素进行运算，True保留，False值设置为NaN
df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)
# 一维布尔数组,对行进行操作，不是对列进行操作
# bArray=[True,True,False]
# display(df[bArray])

# 二维布尔数组，对DataFrame的每一个元素进行运算，True保留，False值设置为NaN
display(df>85)
display(df[df>85])

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	86	80	80

	语文	数学	外语
张三	True	True	True
李四	True	True	True
王五	True	False	False

	语文	数学	外语
张三	100	100.0 100.0
李四	90	90.0  90.0
王五	86	NaN	NaN
  • 标签数组，对列进行操作：
df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

# 标签数组，对列进行操作
lArray = ['语文','数学']
display(df[lArray])

# output:
	语文	数学	外语
张三	100	100	100
李四	90	90	90
王五	86	80	80

	语文	数学
张三	100	100
李四	90	90
王五	86	80
5.8. DataFrame运算

  1. 转置

  2. DataFrame之间运算，不但行索引要对齐，列索引也要对齐，否则产生空值。如果不想要空值，可使用DataFrame的函数代替运算符计算，通过参数 fill_value 参数指定填充值

  3. DataFrame和Series运算，默认Series索引匹配DataFrame列索引，然后进行广播。当然，我们可以通过 axis 参数，指定行索引匹配还是列索引匹配

# 转置操作
df=pd.DataFrame(np.arange(1,5).reshape(2,2))
display(df,df.T)

# output:
	0	1
0	1	2
1	3	4

	0	1
0	1	3
1	2	4

# DataFrame对象之间操作，行索引对齐，列索引也对齐
# df = pd.DataFrame(np.ones((2,2)))
# df2 = pd.DataFrame(np.ones((2,2)))
# display(df,df2)
# display(df+df2)

# DataFrame对象之间操作，行索引、列索引不对齐
df = pd.DataFrame(np.ones((2,2)))
df2 = pd.DataFrame(np.ones((2,2)),index=[1,2],columns=[1,2])
display(df,df2)
# DataFrame对象之间行和列索引不对齐化，首先补齐行索引和列索引，数据填充NaN，然后再进行操作
display(df+df2)
# 如果不想要运算结果为空值的话，就可以使用函数(add)来替换操作符(+),通过fill_value参数指定填充值
display(df.add(df2,fill_value=10))

#output:

	0	1
0	1.0	1.0
1	1.0	1.0

	1	2
1	1.0	1.0
2	1.0	1.0

	0	1	2
0	NaN	NaN	NaN
1	NaN	2.0	NaN
2	NaN	NaN	NaN

	0	1	2
0	11.0	11.0	NaN
1	11.0	2.0	11.0
2	NaN	11.0	11.0
  • DataFrame和Sereis之间运算
# DataFrame和Sereis之间运算
df = pd.DataFrame(np.arange(1,5).reshape(2,2))
s = pd.Series([10,20])
display(df,s)
# 默认Series对象标签和DataFrame的列 标签匹配，广播，再计算
display(df+s)
# 设置Sereis对象标签和DataFrame的行标签匹配，广播，再计算
display(df.add(s,axis='index'))

# output:

	0	1
0	1	2
1	3	4

0    10
1    20
dtype: int64

	0	1
0	11	22
1	13	24

	0	1
0	11	12
1	23	24

6. 排序

6.1. 索引排序

Sereis和DataFrame对象可以使用 sort_index 对索引进行排序。DataFrame还可以通过axis指定对行还是列索引进行排序，也可以通过ascending参数指定升序还是降序排序

# 索引排序
df = pd.DataFrame(np.arange(9).reshape(3,3),index=[3,1,2],columns=[6,4,5])
display(df)

# 对行索引排序
# display(df.sort_index())

# 对列索引排序
# display(df.sort_index(1))

# inplace，True对原有的数据进行排序,sort_index返回None，False对拷贝得到的数据进行排序
# df=df.sort_index(inplace=True)
# display(df)

# ascending指定升降序，False降序，True升序
display(df.sort_index(ascending=False))

#output:
	6	4	5
3	0	1	2
1	3	4	5
2	6	7	8

	6	4	5
3	0	1	2
2	6	7	8
1	3	4	5
6.2. 值排序

Sereis和DataFrame对象使用 sort_value 方法进行值排序

# df = pd.DataFrame([[100,100,100],[90,90,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
# display(df)

# 对列数据， 比如对外语数据进行从小到大的排序
# df.sort_values('外语',axis=0,inplace=True)
# display(df)

# 对行数据，比如王五成绩按照从小到大排序
# display(df.sort_values('王五',axis=1))

# 对多列数据进行排序，比如对语文和数学进行排序,先对语文排序，语文相等，再根据第二列数学进行排序
df = pd.DataFrame([[100,100,100],[100,90,90],[100,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

display(df.sort_values(['语文','数学'],axis=0))

#output:
	语文	数学	外语
张三	100	100	100
李四	100	90	90
王五	100	80	80

	语文	数学	外语
王五	100	80	80
李四	100	90	90
张三	100	100	100

7. 索引对象

Series、DataFrame的 index 或者DataFrame的 columns 都是是一个索引对象

  1. 索引对象可以像数组那样进行索引访问

  2. 索引对象内容是不可修改

df = pd.DataFrame(np.arange(9).reshape(3,3))
display(df)
# index和columns都是索引对象
display(df.index,type(df.index))
display(df.columns,type(df.columns))

index = df.index
display(index[0])

# 不支持修改索引对象中内容
# index[0]=4

# 支持指向一个新的索引对象
index2 = pd.Index([4,5,6])
df.index = index2
display(df)

# output:
	0	1	2
0	0	1	2
1	3	4	5
2	6	7	8
RangeIndex(start=0, stop=3, step=1)

pandas.core.indexes.range.RangeIndex

RangeIndex(start=0, stop=3, step=1)

pandas.core.indexes.range.RangeIndex

0

	0	1	2
4	0	1	2
5	3	4	5
6	6	7	8
  • （上面最后的代码解释）支持指向一个新的索引对象：相当于新创建了一个index对象，并且指向新创建得index对象。

在这里插入图片描述

8. 统计相关方法

  • mean / sum / count
  • max / min
  • cumsum / cumprod
  • argmax / argmin
  • idxmax / idxmin：返回数据最大值所对应的索引，默认按照列
  • var/std
df = pd.DataFrame([[np.nan,np.nan,100],[100,100,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)

# 统计非NaN值的个数，默认按照列来统计；axis=1——设置按照行统计
display(df.count())
display(df.count(axis=1))


# output:
	语文	数学	外语
张三	NaN	NaN	100
李四	100.0	100.0	90
王五	86.0	80.0	80

语文    2
数学    2
外语    3
dtype: int64

张三    1
李四    3
王五    3

df = pd.DataFrame([[100,95,100],[95,100,90],[86,80,80]],index=['张三','李四','王五'],columns=['语文','数学','外语'])
display(df)
# idxmax：返回数据最大值所对应的索引，默认按照列
# display(df.idxmax())
# # axis=1,设置按照行，找到每行最大值对应的索引
# display(df.idxmax(axis=1))

# idxmin回数据最小值所对应的索引，默认按照列
display(df.idxmin())
# axis=1,设置按照行，找到每行最小值对应的索引
display(df.idxmin(axis=1))

# output:
	语文	数学	外语
张三	100	95	100
李四	95	100	90
王五	86	80	80

语文    王五
数学    王五
外语    王五
dtype: object

张三    数学
李四    外语
王五    数学
dtype: object
亚呦u椰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【阶段二】Python数据分析Pandas工具使用07篇：探索性数据分析：数据的描述：数据的集中趋势
胖哥真不错的博客
01-04 661
Python数据分析Pandas工具使用07篇：探索性数据分析：数据的描述：数据的集中趋势
Pandas数据分析库
Littleluck_Dream的博客
07-25 717
目录就是HDF5中的group, 描述了数据集dataset的分类信息，通过group 有效的将多种dataset 进行管理和区分；这些运算是关系型数据库的核心操作。DataFrame是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。HDF5，可以存储不同类型数据的文件格式，后缀通常是.h5，它的结构是层次性的。最直观的理解，可以参考我们的文件管理系统，不同的文件位于不同的目录下。数据中的薪水是一个区间，这里用薪水区间的均值作为相应职位的薪水。
第十三阶段 -- 数据分析06：数据的清理_整理
weixin_42375099的博客
08-03 887
文章目录1. 数据分析什么是数据分析数据分析步骤2. 数据加载3. 写入文件4. 数据清洗4.1. 缺失值处理4.1.1. 发现缺失值4.1.2. 丢弃缺失值4.1.3. 填充缺失值4.2. 无效值处理检测无效值4.3. 重复值处理4.3.1. 发现重复值5. 数据过滤6. 数据转换6.1. 应用与映射6.2. 替换6.3. 字符串向量化运算7. 数据合并7.1. concat7.2. appen...
数据分析-Pandas基础使用及练习
BoringError的博客
04-10 1223
最近在看关于机器学习的相关入门知识，在特征工程中使用了Numpy和Pandas提取样本特征和标签，后来了解到Pandas是一款基于Numpy的高级数据分析库，所以想学习下Pandas数据分析基础内容。
LLM自动进行数据分析-论文《Data-Copilot: Bridging Billions of Data and Humans with Autonomous Workflow》笔记
beingstrong的博客
08-26 1636
让LLM自动进行数据分析，论文《Data-Copilot: Bridging Billions of Data and Humans with Autonomous Workflow》笔记
数据分析-numpy-pandas-matplotlib
qq_59049883的博客
07-05 803
数据分析——numpy-pandas-matpoltlib
银行营销数据分析---Python(numpy、pandas、matplotlib)
c
11-08 8550
本项目采取的是kaggle银行营销的数据源，使用numpy、pandas、matplotlib数据分析三件套，基于源数据，深入分析影响银行三大业务—存款、贷款、营销产品的因素。
【数据分析--Pandas实战指南在真实世界数据中的应用】
最新发布
书生的技术分享
08-04 1038
数据分析的介绍，Python开源库，配置Jupyter，Pandas读取数据
02-pandas数据分析库
March_A的博客
12-03 385
用列表生成 Series时，Pandas 默认自动生成整数索引，也可以指定索引. 第二节 DataFrame DataFrame是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。 第三部分 数据查看 查看DataFrame的常用属性和DataFrame的概览和统计信息: 第四部分 数据输入与输出 第一节 csv文件 第二节 Excel文件 第三节 SQL 第四节 HDF5 HDF5，可以存储不同类型数据的文件格式，后缀通常是.h5，它的
python数据分析与挖掘（二十七）--- Pandas量化--股票基础知识
python爬虫人工智能大数据
01-28 1438
Python教程网：www.python88.cn 1 什么是股票 股票，是股份公司签发的证明股东所持股份的凭证，代表了股东对股份公司净资产的所有权。 特点：每股股票都代表股东对企业拥有单位的所有权，所拥有的份额取决于持有的股票数量总占比。 2 股票按照股东权利的分类 按股东权利分类，股票可分为普通股、优先股等 拓展： 普通股 普通股是指在公司的经营管理和盈利及财产的分配上享有普...
数据分析pandas 基础介绍
qq_47248788的博客
08-30 1284
文章目录 前言 一、pandas是什么？ pandas介绍 pandas与numpy的区别 二、使用步骤 1.引入库 2.读入数据 3.基本操作 三、数据预处理 四、总结 前言 pandas 是Python data analysis 的缩写，是基于Numpy和matplotlib的数据分析库，pandas是在numpy的基础上实现的，所有pandas与numpy有一定的相似之处。 一、pandas是什么？ 1、pandas介绍 pan...
[python]---药品数据分析及预测(包括数据集,源码,报告)
热门推荐
nhdzppx的博客
01-06 1万+
运用python来分析及预测药品销售情况.
第三阶段：【网络通信】
weixin_42375099的博客
06-30 5391
第三阶段：day18_063019【网络通信01】 1. 网络基础 IP地址：常用的是A, B, C三。最常见的是C类。 私有IP / 公有IP IP地址127．0．0．1~127．255．255．255⽤于回路测试 子网掩码：区分网络号和主机号 端口号：用来标记区分进程. 0 — 65535 知名端口：0 — 1023（80：HTTP。3306：MySQL。443：百度。） 动态端口...
【案例】电影数据分析
weixin_42375099的博客
08-05 2546
文章目录数据集数据加载数据探索和清洗评分最多电影评分最高分析评分人数中最多的百部电影评分与年龄关系 数据集 数据集包含3个csv文件，文件中包含电影名字，发行时间，评分用户信息，评分等信息 http://grouplens.org/datasets/movielens/ （使用的dataset是older datasets） 评分表 （u.data） 196 242 3 881250949 1...
【案例】航班准点分析
weixin_42375099的博客
08-06 1833
文章目录1. 数据集2. 数据探索和清洗3. 起飞以及到达延迟情况4. 数据库样式 1. 数据集 数据集为美国各州机场的航班信息，包含出发地，目的地，是否出发延迟15分钟，是否到达延迟15分钟等。 https://www.transtats.bts.gov/Fields.asp?Table_ID=236 import numpy as np import pandas as pd import m...
第十二阶段 -- 爬虫02：【request；数据提取（正则，Beautiful Soup，xpath）】
weixin_42375099的博客
08-05 1522
文章目录1. URLError2. request 库的用法2.1. 基本介绍2.2. get 请求2.3. post 请求2.4. 自定义请求头部2.5. 设置超时时间2.6. 代理访问2.7. session 自动保存 cookies2.8. ssl 验证2.9. request 获取相应信息3. 数据的提取3.1. 正则表达式 re (逼格最高；速度最快)1. 提取数据2. 正则表达式相关注...
【案例】足球运动员分析
weixin_42375099的博客
08-05 1214
文章目录足球运动员分析案例需求数据集程序实现导入相关库加载相关数据集数据探索与清洗身高与体重处理运动员身高，体重，评分信息分布左脚与右脚选手在数量上是否存在偏差从球员平均分角度，拥有top10评分能力俱乐部/国家哪个俱乐部更有能力留住球员(5年及以上)足球运动员是否与出生日期相关身高与体重是否具有相关性哪些指标对评分影响最大年龄和评分具有怎样的关系 足球运动员分析案例 需求 从众多的足球运动员中，...
第十三阶段 -- 数据分析01：Anaconda、IPython、Jupyter Notebook配置
weixin_42375099的博客
07-28 1205
文章目录1. Anaconda简介下载与安装虚拟环境conda包管理器2. IPythonIPython查看帮助命令补全3. Jupyter notebookJupyter notebook启动jupyter停止jupyter设置打开浏览器为Firefox修改默认主目录文件操作单元格1. 类型：2. 模式：3. 常用快捷键： 1. Anaconda 简介 Anaconda是Python的一个免费发...
pandas 第一笔订单开始时间2023-05-18 00:00:00，第一单结束时间2023-05-18 09:00:00，第二笔订单开始时间2023-05-18 09:00:01，第二笔订单结束时间2023-05-18 18:00:01，每一个小时一个单元格按照时间日期排布计划
05-24
2023-05-18 13:00:00 1 2023-05-18 14:00:00 1 2023-05-18 15:00:00 1 2023-05-18 16:00:00 1 2023-05-18 17:00:00 1 2023-05-18 18:00:00 1 ``` 可以看到，每个小时内的订单数量都被正确计算出来了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值