pandas模块

最新推荐文章于 2022-12-21 23:15:18 发布

是小凯呀

最新推荐文章于 2022-12-21 23:15:18 发布

阅读量1.4k

点赞数

本文链接：https://blog.csdn.net/G2231149110/article/details/121852721

版权

python

Pandas简介

定义

一个开源的python类库，用于数据分析、数据处理、数据可视化

特点

高性能、容易使用的数据结构、容易使用的数据分析工具

pandas数据类型

Series是由相同数据类型组成的一维数组。

DataFrame：二维的表格型数据结构，数据帧(**DataFrame**)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）

面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是DataFrame的容器

| **数据结构** | **维数** | **描述**                                                     | **数据** | **大小**   |
| :----------: | -------- | ------------------------------------------------------------ | -------- | ---------- |
|    Series    | 1        | 数据可变，一维数组，大小不可变，Series是由相同数据类型组成的一维数组。 | 数据可变 | 大小不可变 |
|  DataFrame   | 2        | 二维数组，大小可变的表格结构，它含有一组有序的列，每列可以是不同的数据类型（整型、字符串、布尔值等） | 数据可变 | 大小可变   |
|    Panel     | 3        | 数据可变    大小可变的三维数组                               | 数据可变 | 大小可变   |

pandas安装

pip install pandas
pip list

一维数据结构：Series对象

#查看列索引
print(d1.columns)
#查看行索引
print(d1.index)
```

## Series对象的生成

### 使用Pandas.Series

pandas.Series( data, index, dtype, copy)
data:数据,可以是序列类型，可以是int
index:索引值必须是唯一的，与data的长度相同，默认为np.arange(n)
dtype:数据类型
copy:是否复制数据，默认为false
打印左侧为索引，右侧为数据
"""
#如果全部是int类型，那么打印s1会显示是int类型
s1 = pd.Series([1,2,3,4]) #dtype: int64
print(s1)
#如果什么数据类型都存在，那么打印s1会显示object类型的
s1 = pd.Series([1,"a",0.5,["张三","李四"]])#dtype: object
print(s1)
s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
s1 = pd.Series([1,2,3,4],index=['a','b','c','d'],dtype=np.float32)
"""
copy=True后，数据x不会改变，数据s1会改变
copy=False,数据x会改变，数据s1会改变
"""
x=np.array([10,20,30,40])
s1 = pd.Series(x,index=['a','b','c','d'],copy=True)
s1['a']=100
print(s1)
print(x)

从ndarray创建一个Series

x=np.array([10,20,30,40])
s1 = pd.Series(x)
s1 = pd.Series(x,index=['a','b','c','d'])
print(s1)

从字典创建一个Series

由于我们的Series有索引有数据，和我们的字典很像，字典是有key和vaule

#a是索引 100数据
x={'a':100,'b':200,'c':300,'d':400}
s1 = pd.Series(x)
#设置索引
s1 = pd.Series(x,index=['a','b','c','d'])
#如果设置的索引位置换一下呢，数据也会跟着换
s1 = pd.Series(x,index=['a','c','d','b'])
#如果设置的索引，在字典中不存在呢，为nan
s1 = pd.Series(x,index=['a','b','e','f'])
print(s1)

访问Series数据

单个索引获取数据

语法：s1[index] 获取单个数据

#可以使用默认索引，也可以使用自定义索引
s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
print(s1[0])
print(s1['a'])

多个索引获取数据

语法：
s1[list] 获取索引中的数据
s1[index1:index2] 获取从第一个索引到第二个索引的数据，左开右闭
"""

s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
print(s1[0:4]) #左开右闭
print(s1[[0,1,2,3]])
print(s1[['a','b','c']]) 
print(s1['a':'b'])#获取两个数据

Series对象的使用

axes   返回Series索引列表
dtype   返回Series的数据类型
empty   判断Series是否为空，如果为空，则返回True
ndim    返回基础数据的维度数，默认为：1
size    返回基础数据中的元素个数
values  将Series作为ndarray返回
head()  返回前n行
tail()  返回最后n行
head()返回前n行(观察索引值)。默认数量为5，可以传递自定义数值。
tail()返回最后n行(观察索引值)。默认数量为5，可以传递自定义数值。

s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
    'name':s1,
    'age':s2
}
df1=pd.DataFrame(x)

s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,10],index=['row1','row2','row3','row4'])
x1={
    'name':s3,
    'age':s4
}
df2=pd.DataFrame(x1)
print(df2)
print('----------T-转置---------')
print(df2.T)
print("------dtypes--每一列的数据类型----")
print(df2.dtypes)
print("--------empty--------")
print(df2.empty)
print("------ndim-维度数----")
print(df2.ndim)
print("----axes--获取行和列索引-------")
print(df2.axes)
print("-----shape-(行，列)-----")
print(df2.shape)
print("---size---元素个数-----")
print(df2.size)
print("----values--把真正的数据转换成ndarray的形式输出-----")
print(df2.values)
print(type(df2.values))

二维数据结构：DataFrame对象

创建DataFrame对象

"""
pandas.DataFrame( data, index, columns, dtype, copy)
data    支持多种数据类型，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
index    行标签，如果没有传递索引值，默认值为0,1,2,3,4.......
columns    列标签，如果没有传递索引值，默认值为0,1,2,3,4.......
dtype    每列的数据类型
copy    是否复制数据，默认值为False
"""
```

创建空DataFrame对象

df = pd.DataFrame()
print (df)

利用列表创建

#利用单层list

x = [1,2,3,4,5,6]
df = pd.DataFrame(x，dtype=np.float32)
print(df)

#利用双层list

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
#df = pd.DataFrame(x,columns=['name','age'])
#如果是True，那么x数据不改变
df = pd.DataFrame(x,columns=['name','age'，'sex'],copy=True)
df['age'] = 100
print(df)
print(x)

# 利用数据是字典的列表创建

x = [
    {'a':1,'b':2},
    {'a':10,'b':20,'c':30}
]
#index 行索引  columns列索引
df1 = pd.DataFrame(x)
print(df1)
df1 = pd.DataFrame(x,index=["first","second"])
print(df1)
#如果没有c，就会默认是nun
df1 = pd.DataFrame(x,index=["first","second"],columns=['a','c'])
print(df1)

利用字典创建

#利用字典创建DataFrame
#a、b是列索引，一定要设置行索引（index），否则报错

x = {'a':1,'b':2}
d1 = pd.DataFrame(x,index=['row1'])
print(d1)

#字典里面的v是列表类型创建DataFrame
#那么默认列索引是name和age

x = {
    'name':['zs','ls','ww','zl'],
    'age':[14,15,16,17]
}
d1 = pd.DataFrame(x)
print(d1)
print(d1['age'])

利用Series和字典的结合来创建DataFrame

"""
#只有列索引，没有行索引
s1 = pd.Series([1,2,3,4,5,6])
s2 = pd.Series([100,200,300,400,500])
"""

#列索引是one，two，行索引是index
s1 = pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])
s2 = pd.Series([100,200,300,400,500],index=['a','b','c','d','e'])
x = {
    'one':s1,
    'two':s2
}
d1  = pd.DataFrame(x)
print(d1)

列的读取

"""
语法：
df[columns] 查询单列
df[[columns] ] 查询多列
查询出一列和一列都会进行降维DataFrame-----》Series
"""

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
#根据columns获取列数据
print("----------------------")
print(df['name'])
print(type(df['name'])) #<class 'pandas.core.series.Series'>
print("----------------------")
print(df[['name','age']])
print(type(df[['name','age']])) <class 'pandas.core.frame.DataFrame'>

```

列的添加

语法：df[columns] = 数据
切记数据要是同类型的数据，

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
#依据list进行创建的，添加列的时候要是list
x1 = ['nan','nv','nan']
df["three"] = x1
print("---------------------------------------------")
print(df)

语法：
df1[columns]=df1[columns]+df1[columns]

x = [
    {'a':1,'b':2},
    {'a':10,'b':20,'c':30}
]
df1 = pd.DataFrame(x)
print(df1)
# df1['d'] = {'a':2,'b':3} 报错
#数据已经标明列了，不能使用上面的方法，我们可以使用DataFrame中的现有列添加新列
df1['d']=df1['a']+df1['b']
print("--------------------------------")
print(df1)

练习

#把以下数据添加'three'列
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
s3 = pd.Series([10,20,30], index=['a','b','c'])
d = {'one' : s1, 
     'two' : s2}
df = pd.DataFrame(d)
print ("通过传递Series添加一个新列:")
df['three']=s3
print (df)
print ("使用DataFrame中的现有列添加新列:")
df['four']=df['one']+df['three']
print (df)

列的删除
删除语法
del df[columns] 根据下标进行检索删除，没有返回值
df.pop(columns) 根据下标进行检索删除，并返回删除的那一列

df = pd.DataFrame(d)
print ("通过传递Series添加一个新列:")
df['three']=s3
print (df)
del df['one']
print (df)
df_pop = df.pop('two')
print("--------------------------")
print (df_pop) 
print (df)

行的读取
使用loc方法
语法：
loc[index] 查询一行数据
扩展
loc[index,columns] 精确到行和列，那就是一个数据
查询多行和多列（精确到第几行和第几列）
loc[[index1,index2,....],[columns1,columns12,.....]]
查询多行和多列（第几行到第几行,第几列到第几列）
不是左开右闭
loc[index1:index2,columns1：columns2]
使用布尔索引也可以查询多行多列
loc[行_布尔索引,列_布尔索引]

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print(df.loc["row1"])#查询一行数据

print("---------------------------------------")
#查询一个数据 ，精确到第一行。name那一列的数据
print(df.loc["row1","name"])#tom
print("---------------------------------------")
print(df.loc[['row1','row2'],"name"]) #查询第一行和第二行的name

print("---------------------------------------")
print(df.loc[['row1','row2'],['name','age']]) #查询第一行和第二行的name和age

print("---------------------------------------")
print(df.loc['row1',['name','age']]) #第一行的name和age

print("----------------------------------")
print(df.loc['row1':'row3','name'])#查询第一行到第三行的name

print("----------------------------------")
print(df.loc['row1','name':'age']) #第一行的name到age

print("----------------------------------")
print(df.loc['row1':'row3','name':'age'])

print("----------------------------------")
b = df['age']<20
print(b)

print(df.loc[b])  #获取age小于20的行，列是所有列

print("----------------------------------")
print(df.loc[b,'name'])  #获取age小于20的行，列是name

使用df.iloc方法

df.loc方法，根据行、列的标签值查询

df.iloc方法根据行、列的数字位置查询

"""
语法：
iloc[num_index] 根据索引位置获取行
iloc[num_index1:num_index2] 第几行到第几行,左开右闭
iloc[[num_index1,num_index2,.....]] 第几行和第几行
iloc[num_index,num_columns] #第几行的第几列
iloc[num_index,[num_columns1,num_columns2,....]] 第几行，第几列和第几列
iloc[num_index,[num_columns1:num_columns2]] 第几行，第几列到第几列,左开右闭
"""

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("------------------------")
print(df.iloc[2]) #根据索引位置获取行

print("------------------------")
print(df.iloc[0:2])

print("------------------------")
print(df.iloc[[0,2]])

print("------------------------")
print(df.iloc[2,0]) #mike

print("------------------------")
print(df.iloc[2,[0,1]]) 

print("------------------------")
print(df.iloc[2,0:1])

使用切片读取

"""
df[num_index1:num_index2] 第几行到第几行左开右闭---切片
df[label_index1:label_index2] 第几行到第几行，左开右开
"""

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("-----------------------------------------")
print(df[0:2])

print("-----------------------------------------")
print(df['row1':'row3'])

行的添加

"""
在末尾追加一行，返回一个新对象
df.append(other,ignore_index= False,verify_integrity = False,
sort = False)
other：要附加的数据，DataFrame或者Series等类型
ignore_index：如果是True，则不使用索引标签，默认false
verify_integrity：如果是True，在创建于重复项的索引时，引发valueError，默认时false
sort：如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
"""

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("-----------------------------------------")
y = [
    ["zs",10],
    ["ls",20],
    ["ww",30]
]
df1 = pd.DataFrame(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1)
print(df2)
"""
-----------------------------------------
      name  age
row1   tom   10
row2  jack   20
row3  mike   30
row1    zs   10
row2    ls   20
row3    ww   30
"""

print("-------------ignore_index=True，则不使用索引标签----------------------------")
df1 = pd.DataFrame(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1,ignore_index=True)
print(df2)

print("------verify_integrity=True，在创建于重复项的索引时，引发valueError-------")
df1 = pd.DataFrame(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1,verify_integrity=True)
print(df2)

行的删除

"""
df1= df.drop(index) #删除某行，返回一个新数据
"""

x = [
    ["tom",10],
    ["jack",20],
    ["mike",30]
]
df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("--------------------------")
df1= df.drop('row1')
print(df1)

DataFrame的属性和方法

| **属性和方法** | **描述**                                           |
| -------------- | -------------------------------------------------- |
| T              | 转置行和列                                         |
| axes           | 返回一个列，行轴标签和列轴标签作为唯一的成员       |
| dtypes         | 返回此对象中的数据类型                             |
| empty          | 如果DataFrame为空，则返回为True，任何轴的长度都为0 |
| ndim           | 数组维度大小，默认为2维                            |
| shape          | 返回表示DataFrame的维度的元组                      |
| size           | DataFrame中的元素个数                              |
| values         | 将DataFrame中的实际数据作为NDarray返回             |
| head()         | 返回开头n行                                        |
| tail()         | 返回最后n行                                        |

s1 =pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack'])
s2 = pd.Series([25,26,25,23,30,29,23])
s3 = pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])
d = {'Name':s1,
   'Age':s2,
   'Rating':s3}
#生成一个DataFrame对象
df = pd.DataFrame(d)
print (df)

"""
    Name  Age  Rating
0    Tom   25    4.23
1  James   26    3.24
2  Ricky   25    3.98
3    Vin   23    2.56
4  Steve   30    3.20
5  Minsu   29    4.60
6   Jack   23    3.80
"""

print("--------df.T返回DataFrame的转置，行和列将交换----------")
df_T = df.T
print(df_T)

"""
--------df.T返回DataFrame的转置，行和列将交换----------
           0      1      2     3      4      5     6
Name     Tom  James  Ricky   Vin  Steve  Minsu  Jack
Age       25     26     25    23     30     29    23
Rating  4.23   3.24   3.98  2.56    3.2    4.6   3.8
"""

print("--------df.axes返回行轴标签和列轴标签列表----------")
df_axes = df.axes
print(df_axes)
#[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]
print("--------df.dtypes返回每列的数据类型----------")
df_dtype = df.dtypes
print(df_dtype)

"""
--------df.dtypes返回每列的数据类型----------
Name       object
Age         int64
Rating    float64
dtype: object
"""

print("--------df.empty返回布尔值，表示对象是否为空，返回True表示对象为空----------")
df_empty = df.empty
print(df_empty) #False
print("--------df.ndim返回对象的维数----------")
df_ndim = df.ndim
print(df_ndim )  #2

print("-----df.shape返回表示DataFrame的维度的元组。元组(a，b)，其中a表示行数，b表示列数-")
df_shape = df.shape
print(df_shape  )  #(7, 3)
print("-----df.size返回DataFrame中的元素个数。----")
df_size = df.size
print(df_size  )  #21
print("-----df.values将DataFrame中的实际数据作为NDarray返回。----")
df_values = df.values
print(df_values)  

print("-----df.head(n)返回前n行(观察索引值)。默认数量为5----")
df_head = df.head(2)
print(df_head)  

print("-----df.tail(n)返回后n行(观察索引值)。默认数量为5----")
df_tail = df.tail(2)
print(df_tail)

是小凯呀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
pandas模块

Pandas简介定义一个开源的python类库，用于数据分析、数据处理、数据可视化特点高性能、容易使用的数据结构、容易使用的数据分析工具pandas数据类型Series是由相同数据类型组成的一维数组。DataFrame：二维的表格型数据结构，数据帧(**DataFrame**)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是DataFrame的容器|**数据结构**|**维数**|**描述...
复制链接

扫一扫