Python学习（三）pandas包

这个对数不太对

已于 2023-08-22 19:24:29 修改

阅读量209

点赞数

分类专栏： Python 文章标签： pandas python

于 2023-08-14 20:26:45 首次发布

本文链接：https://blog.csdn.net/m0_57060319/article/details/132284494

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.简介

pandas 是 python 中基于 numpy 和 matplotlib 的第三方数据分析库，与后两者共同构成了python数据分析的基础工具包。

2.数据对象

2.1 Series 对象

2.1.1 参数

index：标签信息，未指定索引默认从0开始的自然数
values：保存元素值的 ndarray 数组

创建 Series 对象

# TODO:创建series对象
import pandas as pd

#1.未指定index,series对象则默认生成index
series1 = pd.Series([2, 3, 5, 9])
print("未指定索引的series1:\n", series1)

#2.指定index, series对象的index则按照指定的进行生成
series2 = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print("指定索引的series2:\n", series2)

运行结果
未指定索引的series1:
0    2
1    3
2    5
3    9
指定索引的series2:
a    1
b    2
c    3
d    4
e    5

2.1.2 操作说明

访问 series 对象同时支持位置和标签形式
支持位置切片和标签切片
+：对标签相同的元素进行加法计算，另一方不存在时，以 NAN 填充
isnull / notnull 检测数据是否为空

2.2 DataFrame 对象

2.2.1 参数

data：数据
index：行索引
column：列索引

用字典创建 DataFrame 对象

# TODO: 字典生成 DataFrame
import pandas as pd

# 字典创建dataFrame
# 字典的"键"是列名
# 字典"键"的值是一个列表
# DataFrame没有指定索引会默认生成
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
print("DataFrame:\n", frame)

# DataFrame 对象拥有行索引（可以有多级索引）index和列索引columns
print("DataFrame的行索引:", frame.index)
print("DataFrame的列索引:", frame.columns)
print("DataFrame的行索引0:", frame.index[0])
print("DataFrame的列索引2:", frame.columns[2])

# 给一个不存在的列赋值，将会创建一个新的列。
frame["day"] = None
print(frame)
# 像字典一样 del 关键字将会删除列：
del frame["day"]
print(frame)

运行结果
DataFrame:
     state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

DataFrame的行索引: RangeIndex(start=0, stop=5, step=1)
DataFrame的列索引: Index(['state', 'year', 'pop'], dtype='object')
DataFrame的行索引0: 0
DataFrame的列索引2: pop

    state  year  pop   day
0    Ohio  2000  1.5  None
1    Ohio  2001  1.7  None
2    Ohio  2002  3.6  None
3  Nevada  2001  2.4  None
4  Nevada  2002  2.9  None

    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

用ndarray创建DataFrame

# TODO:用ndarray创建DataFrame对象
frame1 = pd.DataFrame(np.random.randint(0, 10, (4, 2)), index=['A', 'B', 'C', 'D'], columns=['a', 'b'])
print("用ndarray创建DataFrame:\n", frame1)

运行结果
用ndarray创建DataFrame:    
   a  b
A  9  1
B  4  7
C  2  4
D  5  0

2.3 Index 对象

index 对象保存索引标签数据，可以当作一维数组，只读。

# 通过values属性获得保存标签的数组
import pandas as pd

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
index = frame.columns
print("\n", frame)
print("frame列标签:", index)
print("frame列标签的值:", index.values)

# Index 对象也有字典的映射功能，将值映射到键的位置:
print(index.get_loc('state'))
print(index.get_indexer(['state', 'year']))

运行结果
     state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9
frame列标签: Index(['state', 'year', 'pop'], dtype='object')
frame列标签的值: ['state' 'year' 'pop']
0
[0 1]

2.4 Multindex 对象

MultiIndex表示多级索引，它从Index继承，其中的多级标签采用元组对象来表示

创建MultiIndex的4种方法：

pandas.MultiIndex.from_arrays ：从数组创建
pandas.MultiIndex.from_product：从笛卡尔积创建
pandas.MultiIndex.from_tuples ：从元组创建
pandas.MultiIndex.from_frame ：由DataFrame对象创建

import pandas as pd
import numpy as np

# 从数组创建
class1 = ["A", "A", "B", "B"]
class2 = ["x", "y", "x", "y"]
m_arr = pd.MultiIndex.from_arrays([class1, class2],names=["class1", "class2"])
df1 = pd.DataFrame(np.random.randint(0, 10, (4, 4)), columns=m_arr, index=m_arr)
print(df1)

# 从笛卡尔积创建
m_pro = pd.MultiIndex.from_product([["A", "B", "C"], ["x", "y"]], names=["class1", "class2"])
df2 = pd.DataFrame(np.random.randint(0, 10, (6, 6)), columns=m_pro, index=m_pro)
print(df2)

# 从元组创建
m_tup = pd.MultiIndex.from_tuples([("A","x1"),("A","x2"),("B","y1"),("B","y2"),("B","y3")],name=["class1","class2"])
df3 = pd.DataFrame(np.random.randint(0, 10, (5, 5)), columns=m_tup, index=m_tup)
print(df3)

运行结果
class1         A     B   
class2         x  y  x  y
class1 class2            
A      x       0  4  9  9
       y       9  2  2  4
B      x       5  1  8  4
       y       4  6  9  7
       
class1         A     B     C   
class2         x  y  x  y  x  y
class1 class2                  
A      x       1  0  3  6  2  5
       y       0  0  6  3  9  2
B      x       4  5  7  4  8  0
       y       7  8  2  3  3  0
C      x       7  7  5  4  9  8
       y       4  8  7  9  9  9
       
class1         A     B      
class2        x1 x2 y1 y2 y3
class1 class2               
A      x1      0  3  9  6  7
       x2      2  9  7  0  3
B      y1      6  3  8  4  5
       y2      9  7  2  2  8
       y3      6  9  6  5  3

3.下标存取

3.1 [ ] 操作符

单个索引标签：获取对应的列，返回一个Series对象。name是列索引名，index是行索引,values是数值。
多个索引标签：获取以列表、数组表示的多个标签对应的列，返回一个DataFrame 对象。
整数切片：以整数下标获取切片对应的行，不包含终值的行。
标签切片：当使用标签作为切片时包含终值。
布尔数组：获取数组中 True 对应的行

import numpy as np
import pandas as pd

# TODOl下标存取
# []操作符
A = pd.DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])
print(A)

# 单个索引标签:获取对应的列，返回一个Series对象:name是列索引名,index是行索引,values是数值
# 在此基础上，使用两个[col][row]时可返回对应位置的元素
# 行索引可以用标签也可以用整数索引，列标签只能用标签索引
print("单个列索引标签:\n", A['Ohio'])
print("单个列索引标签的行索引:", A['Ohio'].index)
print("单个列索引标签的值:", A['Ohio'].values)
print("单个列标签索引的列名:", A['Ohio'].name)

# 多个索引标签： 获取以列表、数组表示的多个标签对应的列，返回一个DataFrame 对象。
C = A[['Ohio', 'Texas']]
print("多个列索引标签:\n", C)
print("多个列索引标签返回值类型:", type(C))

# 整数切片：以整数下标获取切片对应的行，不包含终值的行。  数值就是
print("整数切片:\n", A[0:2])
# 标签切片:当使用标签作为切片时包含终值
print("标签切片:\n", A['a':'c'])
# 布尔数组:获取数组中True对应的行
print("获取数组中True对应的行:\n", A[A.Ohio > 0])

运行结果
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

单个列索引标签:
a    0
c    3
d    6
Name: Ohio, dtype: int32
单个列索引标签的行索引:Index(['a', 'c', 'd'], dtype='object')
单个列索引标签的值:[0 3 6]
单个列标签索引的列名: Ohio

多个列索引标签:    
    Ohio  Texas
a     0      1
c     3      4
d     6      7
多个列索引标签返回值类型: <class 'pandas.core.frame.DataFrame'>

整数切片:
    Ohio  Texas  California
a     0      1           2
c     3      4           5
标签切片:
    Ohio  Texas  California
a     0      1           2
c     3      4           5
获取数组中True对应的行:
    Ohio  Texas  California
c     3      4           5
d     6      7           8

3.2 .loc[] 和.iloc[] 存取器

.loc[]使用标签下标, .iloc[]使用整数下标, .ix[]可以混用
下标对象是一个元组,有两个对象与行,列两个轴对应,若只有一个对象则对应[行,:]
注：[:,列]是不可行的

import numpy as np
import pandas as pd
# TODO:.loc[]和.iloc[]存取器

# .loc[]使用标签下标
array = np.arange(16).reshape((4, 4))
X = pd.DataFrame(array, index=['a', 'c', 'd', 'e'], columns=['A', 'B', 'C', 'D'])
print(X)

# loc[]使用索引标签下标
print("输出B.loc['a':'c']:\n",X.loc['a':'c'])
print("输出B.loc['a':'c','B':'C']:\n",X.loc['a':'c','B':'C'])

#bool
print(X.loc['a':'d',['B','D']])
print(X.loc[X.C>3,['B','D']])

# .iloc[] 使用整数下标
print("B.iloc[1:]:\n",X.iloc[1:])

运行结果
    A   B   C   D
a   0   1   2   3
c   4   5   6   7
d   8   9  10  11
e  12  13  14  15

输出B.loc['a':'c']:
   A  B  C  D
a  0  1  2  3
c  4  5  6  7
输出B.loc['a':'c','B':'C']:
   B  C
a  1  2
c  5  6

   B   D
a  1   3
c  5   7
d  9  11
    B   D
c   5   7
d   9  11
e  13  15

B.iloc[1:]:
    A   B   C   D
c   4   5   6   7
d   8   9  10  11
e  12  13  14  15

3.3 获取单个值

.at[]和.iat[]分别使用标签和整数下标获取单个值，此外 get_value()与.at[]类似，不过其执行速度较快。

import numpy as np
import pandas as pd

# TODO:获取单个值
# .at[]和.iat[]分别使用标签和整数下标获取单个值，此外get_value()与.at[]类似，不过其执行速度要快一些：
#  创建数组
array = np.arange(16).reshape((4, 4))
X = pd.DataFrame(array, index=['a', 'c', 'd', 'e'], columns=['A', 'B', 'C', 'D'])
print(X)
print("X.at['c','B']即c行B列:",X.at['c','B'])
print("X.iat[1,1]即1行1列:",X.iat[1,1])

运行结果
    A   B   C   D
a   0   1   2   3
c   4   5   6   7
d   8   9  10  11
e  12  13  14  15
X.at['c','B']即c行B列: 5
X.iat[1,1]即1行1列: 5

3.4 query() 方法

当需要根据一定的条件对行进行过滤吋，通常可以先创建一个布尔数组，使用该数组获取 True 对应的行。可以使用先前的[ ]运算符使用~、&、|等位运算，也可以采用query()使用 not and or等关键字。

# TODO:Query()方法
import numpy as np
import pandas as pd

#  创建数组
array = np.arange(16).reshape((4, 4))
X = pd.DataFrame(array, index=['a', 'c', 'd', 'e'], columns=['A', 'B', 'C', 'D'])

print("X[(X.B>1)&(X.D<15)]:\n", X[(X.B>1)&(X.D<15)])
print("X.query('B>1 and D<15')",X.query("B>1 and D<15"))

运行结果
X[(X.B>1)&(X.D<15)]:
   A  B   C   D
c  4  5   6   7
d  8  9  10  11

X.query('B>1 and D<15')
   A  B   C   D
c  4  5   6   7
d  8  9  10  11

4. 文件输入输出

read_csv()从文本文件读入数据，它的可选参数非常多，下面只简要介绍一些常用参数:

sep参数指定数据的分隔符号，可以使用正则表达式，默认值为逗号。有时csv文件为了便于阅读，在逗号之后添加了一些空格以对齐每列的数据。如果希望忽略这些空格，可以将skipinitialspace参数设置为True。
若数据使用空格或制表符分隔，可以不设置 sep参数，而将delim_whitespace参数设置为Tnue。
默认情况下第一行文本被作为列索引标签，如果数据文件中没有保存列名的行，可以设置header参数为0。
如果数据文件之前包含一些说明行，可以使用skiprows参数指定数据开始的行号。na_values、true_values 和l false_values等参数分别指定NaN、True和l False对应的字符串列表。
如果希望从字符串读入数据，可以使用io.BytesIO(string)将字符串包装成输入流。
如果希望将字符串转换为时间，可以使用parse_dates指定转换为时间的列。
如果数据中包含中文，可以使用encoding参数指定文件的编码，例如"utf-8"、"gbk"等。指定编码之后得到的字符串列为Unicode字符串。
可以使用usecols参数指定需要读入的列。
当文件很大时,可以用chunksize参数指定一次读入的行数。当使用chunksize时, read_csv()返回一个迭代器。
当文件名包含中文时，需要使用Unicode字符串指定文件名。

import pandas as pd
# TODO:文件的输入输出
# 使用chunksize迭代读取

list = []
table_reader = pd.read_csv('data.csv',encoding='utf-8',chunksize=10)
print(type(table_reader))
for tb in table_reader:
    list.append(tb)
print(list[0])

#正常读取返回一个DataFrame对象
table = pd.read_csv('data.csv',encoding='utf-8')
print(type(table))
print(table.loc[1])