Pandas操作总结

Posted TheExi

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Pandas操作总结相关的知识，希望对你有一定的参考价值。

3.1Pandas

3.1.1 Series

class pandas.Series(data = None, index = None, dtype = None, name = None, copy = False, fastpath = False)
  • data 表示传入的数据
  • index 表示索引
  • dtype 数据类型，默认会自己判断
  • name 设置名称
  • copy 拷贝数据，默认为 False
//通过传入列表创建series对象
import pandas as pd
a = ["Google", "Runoob", "Wiki"]
myvar = pd.Series(a, index = ["x", "y", "z"])
print(myvar)

//通过字典(键值对)创建Series
import pandas as pd
sites = 1: "Google", 2: "Runoob", 3: "Wiki"
myvar = pd.Series(sites)
print(myvar)

注：以下均为jupyter中代码实例

In [1]:

import pandas as pd                       # 导入pandas库
ser_obj = pd.Series([1, 2, 3, 4, 5])      # 创建Series类对象
ser_obj

Out[1]:

0    1
1    2
2    3
3    4
4    5
dtype: int64

In [2]:

# 创建Series类对象，并指定索引
ser_obj = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
ser_obj

Out[2]:

a    1
b    2
c    3
d    4
e    5
dtype: int64

In [3]:

year_data = 2001: 17.8, 2002: 20.1, 2003: 16.5
ser_obj2 = pd.Series(year_data)   # 创建Series类对象
ser_obj2

Out[3]:

2001    17.8
2002    20.1
2003    16.5
dtype: float64

In [4]:

ser_obj.index         # 获取ser_obj的索引

Out[4]:

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In [5]:

ser_obj.values       # 获取ser_obj的数据

Out[5]:

array([1, 2, 3, 4, 5], dtype=int64)

In [5]:

ser_obj[3]            # 获取位置索引3对应的数据

Out[5]:

4

In [6]:

ser_obj * 2

Out[6]:

a     2
b     4
c     6
d     8
e    10
dtype: int64

3.1.2 DataFrame

pandas.DataFrame(data, index, columns, dtype, copy)
  • data：一组数据(ndarray,series, map, lists, dict 等类型)
  • index：索引值，或者可以称为行标签
  • columns：列标签，默认为 RangeIndex (0, 1, 2, …, n)
  • dtype：数据类型
  • copy：拷贝数据，默认为 False

In [7]:

import numpy as np
import pandas as pd

demo_arr = np.array([['a', 'b', 'c'], ['d', 'e', 'f']]) 
# 创建数组
df_obj = pd.DataFrame(demo_arr)    # 基于数组创建DataFrame对象
df_obj

Out[7]:

012
0abc
1def

In [8]:

# 创建DataFrame对象，指定列索引
df_obj1 = pd.DataFrame(demo_arr, columns=['No1', 'No2', 'No3'])
df_obj1

Out[8]:

No1No2No3
0abc
1def

In [10]:

element = df_obj1['No2']  # 通过列索引的方式获取一列数据
element

Out[10]:

0    b
1    e
Name: No2, dtype: object

In [11]:

type(element)                # 查看返回结果的类型

Out[11]:

pandas.core.series.Series

In [11]:

element = df_obj1.No2  # 通过属性获取列数据
element

Out[11]:

0    b
1    e
Name: No2, dtype: object

In [12]:

type(element)           # 查看返回结果的类型

Out[12]:

pandas.core.series.Series

In [13]:

df_obj1['No4'] = ['g', 'h']
df_obj1

Out[13]:

No1No2No3No4
0abcg
1defh

In [14]:

del df_obj1['No4']
df_obj1

Out[14]:

No1No2No3
0abc
1def

3.2 索引操作及高级索引

3.2.1 索引对象

In [15]:

import pandas as pd
ser_obj = pd.Series(range(5), index=['a','b','c','d','e'])
ser_index = ser_obj.index
ser_index

Out[15]:

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In [16]:

ser_obj

Out[16]:

a    0
b    1
c    2
d    3
e    4
dtype: int64

In [17]:

ser_index['2'] = 'cc'  # (执行时，将注释打开，便可以看到错误信息)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-17-3d779dc501cd> in <module>
----> 1 ser_index['2'] = 'cc'  # (执行时，将注释打开，便可以看到错误信息)

c:\\users\\dell\\anaconda3\\envs\\pyg\\lib\\site-packages\\pandas\\core\\indexes\\base.py in __setitem__(self, key, value)
   4082 
   4083     def __setitem__(self, key, value):
-> 4084         raise TypeError("Index does not support mutable operations")
   4085 
   4086     def __getitem__(self, key):

TypeError: Index does not support mutable operations

In [22]:

ser_obj1 = pd.Series(range(3), index=['a','b','c'])
ser_obj2 = pd.Series(['a','b','c'], index=ser_obj1.index)
ser_obj2.index is ser_obj1.index

Out[22]:

True

In [19]:

ser_obj1

Out[19]:

a    0
b    1
c    2
dtype: int64

In [20]:

ser_obj2

Out[20]:

a    a
b    b
c    c
dtype: object

3.2.2 重置索引

In [23]:

import pandas as pd


ser_obj = pd.Series([1, 2, 3, 4, 5], index=['c', 'd', 'a', 'b', 'e'])
ser_obj

Out[23]:

c    1
d    2
a    3
b    4
e    5
dtype: int64

In [24]:

# 重新索引
ser_obj2 = ser_obj.reindex(['a', 'b', 'c', 'd', 'e', 'f']) 
ser_obj2

Out[24]:

a    3.0
b    4.0
c    1.0
d    2.0
e    5.0
f    NaN
dtype: float64

In [21]:

# 重新索引时指定填充的缺失值
ser_obj2 = ser_obj.reindex(['a', 'b', 'c', 'd', 'e', 'f'], fill_value = 6)
ser_obj2

Out[21]:

a    3
b    4
c    1
d    2
e    5
f    6
dtype: int64

In [25]:

# 创建Series对象，并为其指定索引
ser_obj3 = pd.Series([1, 3, 5, 7], index=[0, 2, 4, 6])
ser_obj3

Out[25]:

0    1
2    3
4    5
6    7
dtype: int64

In [27]:

ser_obj3.reindex(range(6), method = 'ffill') # 重新索引，前向填充值

Out[27]:

0    1
1    1
2    3
3    3
4    5
5    5
dtype: int64

In [28]:

ser_obj3.reindex(range(6), method = 'bfill')# 重新索引，后向填充值

Out[28]:

0    1
1    3
2    3
3    5
4    5
5    7
dtype: int64

3.2.3 索引操作

In [25]:

import pandas as pd


ser_obj = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
ser_obj[2]       # 使用索引位置获取数据

Out[25]:

3

In [26]:

ser_obj['c']    # 使用索引名称获取数据

Out[26]:

3

In [27]:

ser_obj[2: 4]           # 使用位置索引进行切片（我们看到区间是左闭右开的，这种语法符合python的一贯风格）

Out[27]:

c    3
d    4
dtype: int64

In [28]:

ser_obj['c': 'e']      # 使用索引名称进行切片

Out[28]:

c    3
d    4
e    5
dtype: int64

In [29]:

ser_obj[[0, 2, 4]]          # 通过不连续位置索引获取数据集

Out[29]:

c    1
a    3
e    5
dtype: int64

In [30]:

ser_obj[['a', 'c', 'd']]   # 通过不连续索引名称获取数据集

Out[30]:

a    1
c    3
d    4
dtype: int64

In [30]:

ser_bool = ser_obj > 2         # 创建布尔型Series对象
ser_bool

Out[30]:

c    False
d    False
a     True
b     True
e     True
dtype: bool

In [32]:

ser_obj[ser_bool]               # 获取结果为True的数据

Out[32]:

c    3
d    4
e    5
dtype: int64

In [31]:

arr = np.arange(12).reshape(3, 4)
df_obj = pd.DataFrame(arr, columns=['a', 'b', 'c', 'd'])
df_obj

Out[31]:

abcd
00123
14567
2891011

In [34]:

df_obj['b']

Out[34]:

0    1
1    5
2    9
Name: b, dtype: int32

In [35]:

type(df_obj['b'])

Out[35]:

pandas.core.series.Series

In [36]:

df_obj[['b', 'd']]        # 获取不连续的Series对象

Out[36]:

bd
013
157
2911

In [37]:

df_obj[: 2]               # 使用切片获取第0~1行的数据

Out[37]:

abcd
00123
14567

In [38]:

# 使用多个切片先通过行索引获取第0~2行的数据，再通过不连续列索引获取第b、d列的数据
df_obj[: 3][['b', 'd']]

Out[38]:

bd
013
157
2911
用loc和iloc花式索引

In [32]:

arr = np.arange(16).reshape(4, 4)
dataframe_obj = pd.DataFrame(arr, columns=['a', 'b', 'c', 'd'])
dataframe_obj

Out[32]:

abcd
00123
14567
2891011
312131415

In [33]:

dataframe_obj.loc[:, ["c", "a"]]

Out[33]:

ca
020
164
2108
31412

In [34]:

dataframe_obj.iloc[:, [2, 0]]

Out[34]:

ca
020
164
2108
31412

In [35]:

dataframe_obj.loc[1:2, ['b','c']]#注意和iloc区别，loc对于行索引是双闭区间,iloc为左闭右开

Out[35]:

bc
156
2910

In [36]:

dataframe_obj.iloc[1:3, [1, 2]]//iloc行索引为左闭右开

Out[36]:

bc
156
2910

3.3 算术运算与数据对齐

In [37]:

obj_one = pd.Series(range(10, 13), index=range(3)) 
obj_one

Out[37]:

0    10
1    11
2    12
dtype: int64

In [38]:

obj_two = pd.Series(range(20, 25), index=range(5))
obj_two

Out[38]:

0    20
1    21
2    22
3    23
4    24
dtype: int64

In [39]:

obj_one + obj_two

Out[39]:

0    30.0
1    32.0
2    34.0
3     NaN
4     NaN
dtype: float64
//可以看到默认填充为NaN

In [40]:

obj_one.add(obj_two, fill_value = 0)   # 执行加法运算，补充缺失值

Out[40]:

0    30.0
1    32.0
2    34.0
3    23.0
4    24.0
dtype: float64
//注意:这里补充的缺失值是obj_one的缺失值填充而不是对加完的数据进行填充

3.4 数据排序

3.4.1 按索引排序

In [41]:

import pandas as pd
ser_obj = pd.Series(range(10, 15), index=[5, 3, 1, 3, 2])
ser_obj

Out[41]:

5    10
3    11
1    12
3    13
2    14
dtype: int64

In [42]:

ser_obj.sort_index()        # 按索引进行升序排列

Out[42]:

1    12
2    14
3    11
3    13
5    10
dtype: int64

In [43]:

ser_obj.sort_index(ascending = False)  # 按索引进行降序排列

Out[43]:

5    10
3    11
3    13
2    14
1    12
dtype: int64

In [44]:

import pandas as pd
import numpy as np
df_obj = pd.DataFrame(np.arange(9).reshape(3, 3), index=[4, 3, 5])
df_obj

Out[44]:

012
4012
3345
5678

In [45]:

df_obj.sort_index()                      # 按索引升序排列

Out[45]:

012
3345
4012
5678

In [46]:

df_obj.sort_index(ascending = False)     # 按索引降序排列

Out[46]:

012
5678
4012
3345

3.4.2 按值排序

In [49]:

ser_obj = pd.Series([4, np.nan, 6, np.nan, -3, 2])
ser_obj

Out[49]:

0    4.0
1    NaN
2    6.0
3    NaN
4   -3.0
5    2.0
dtype: float64

In [50]:

ser_obj.sort_values()   # 按值升序排列

Out[50]:

4   -3.0
5    2.0
0    4.0
2    6.0
1    NaN
3    NaN
dtype: float64

In [51]:

df_obj = pd.DataFrame([[0.4, -0.1, -0.3, 0.0], 
                       [0.2, 0.6, -0.1, -0.7],
                       [0.8, 0.6, -0.5, 0.1]])
df_obj

Out[51]:

0123
00.4-0.1-0.30.0
10.20.6-0.1-0.7
20.80.6-0.50.1

In [53]:

df_obj.sort_values(by = 2)  # 对列索引值为2的数据进行排序

Out[53]:

0123
20.80.6-0.50.1
00.4-0.1-0.30.0
10.20.6-0.1-0.7

3.5 统计计算与描述

3.5.1 常用的统计计算

In [54]:

df_obj = pd.DataFrame(np.arange(12).reshape(3, 4), columns=['a', 'b', 'c', 'd'])
df_obj

Out[54]:

abcd
00123
14567
2891011

In [59]:

df_obj.sum()          # 计算每列元素的和

Out[59]:

a    12
b    15
c    18
d    21
dtype: int64

In [60]:

df_obj.max()         # 获取每列的最大值

Out[60]:

a     8
b     9
c    10
d    11
dtype: int32

In [61]:

df_obj.min(axis=1)   # 沿着横向轴，获取每行的最小值，axis默认为0

Out[61]:

0    0
1    4
2    8
dtype: int32

3.5.2 统计描述（descript）

In [62]:

df_obj = pd.DataFrame([[12, 6, -11, 19], 
                       [-1, 7, 50, 36],
                       [5, 9, 23, 28]])
df_obj

Out[62]:

0123
0126-1119
1-175036
2592328

In [55]:

df_obj.describe()#提供数据各种维度的描述

Out[55]:

abcd
count3.03.03.03.0
mean4.05.0以上是关于Pandas操作总结的主要内容，如果未能解决你的问题，请参考以下文章

pandas高级操作总结

Pandas 学习总结

pandas dataframe 操作技巧 总结

python pandas multiindex片段

pandas GroupBy上的方法apply:一般性的“拆分-应用-合并”

总结--- Numpy和Pandas库常用函数

(c)2006-2024 SYSTEM All Rights Reserved IT常识