python数据分析之pandas（完善中）

じ星不离月か

已于 2023-01-17 20:28:30 修改

阅读量181

点赞数

分类专栏： python数据分析文章标签： python pandas 数据分析

于 2023-01-10 16:28:02 首次发布

本文链接：https://blog.csdn.net/weixin_43996664/article/details/128617614

版权

python数据分析专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文仅记录了一些自己会使用到的知识，若没有帮到您，我感到很抱歉！

导入：

import pandas as pd

文章目录

一、Series
- 1. 创建Series
- 2. 切片和索引
二、DataFrame
三、时间序列
- 1. 创建时间序列
四、补充

一、Series

1. 创建Series

（1）pd.Series()中参数如下：

    def __init__(
        self,
        data=None, # 数据，常用参数
        index=None,	# 索引，常用参数
        dtype: Dtype | None = None, # 所存储的数据类型，常用参数
        name=None,
        copy: bool = False,
        fastpath: bool = False,
    ):

（2）创建一个Series

# 1. 以数组形式创建
arr = [1, 2, 3, 41, 12]
s1 = pd.Series(arr, index=['a', 'b', 'c', 'd', 'e'])
# 2. 以字典形式创建
temp_dict = {"name": "xiaoming", "age": 17, "sex": "男"}
s2 = pd.Series(temp_dict )
print(s1)
print(s2)

输出：

a     1
b     2
c     3
d    41
e    12
dtype: int64

name    xiaoming
age      17
sex       男
dtype: object

（3）修改数据类型

print(s1.astype("float"))

输出：

a     1.0
b     2.0
c     3.0
d    41.0
e    12.0
dtype: float64

2. 切片和索引

数据如下（1-4）：

s1 = pd.Series({"name": "xiaoming", "age": 17, "sex": "男", "phone": "10086"})
print(s1)

输出：

name     xiaoming
age            17
sex             男
phone       10086
dtype: object

（1）获取键和值

print(s1.index)
print(s1.values)

输出：

Index(['name', 'age', 'sex', 'phone'], dtype='object')
['xiaoming' 17 '男' '10086']

（2）通过键或者索引取值

print(s1["age"])  # 取age的值
print(s1[1])  # 取第二个数据，即age的值

输出：

17
17

（3）取连续的多行

print(s1[2:])

输出：

sex          男
phone    10086
dtype: object

（4）取不连续的多行

print(s1[[2, 0]])
print(s1[["age", "name"]])

输出：

sex            男
name    xiaoming
dtype: object

age           17
name    xiaoming
dtype: object

（5）布尔索引

数据如下：

data = pd.Series([1, 5, 4, 12, 8, 6, 35])
print(data[data < 10])

输出：

0    1
1    5
2    4
4    8
5    6
dtype: int64

二、DataFrame

1. 创建DataFrame

（1）pd.DataFrame()中参数如下：

    def __init__(
        self,
        data=None, # 数据
        index: Axes | None = None, # 行索引， 常用参数
        columns: Axes | None = None, # 列索引， 常用参数
        dtype: Dtype | None = None, # 所存储的数据类型， 常用参数
        copy: bool | None = None,
    ):

（2）创建一个DataFrame

# 1. 以数组的形式创建
arr = [[1, 2, 3, 4], [8, 7, 6, 5]]
df = pd.DataFrame(arr)
print(df)
# 2. 以字典形式创建--列
dict1 = {"name": ["xiaoming", "xiaogang"], "age": [17, 19], "tel": ["10086", "10010"]}
df1 = pd.DataFrame(dict1, index=list("ab"))
print(df1)
# 3. 以字典形式创建--行
dict2 = [{"name": "xiaoming", "age": 17, "tel": "10086"}, {"name": "xiaogang", "age": 19, "tel": "10010"}]
df2 = pd.DataFrame(dict2, index=list("ab"))
print(df2)
# 4. 读取csv文件创建
file_path = "./data3.csv"
df3 = pd.read_csv(file_path, header=None) # 默认以csv文件中第一行为列索引，如第一行为数据，将header设置为None即可
print(df3)

输出df：

   0  1  2  3
0  1  2  3  4
1  8  7  6  5

输出df1：

       name  age    tel
a  xiaoming   17  10086
b  xiaogang   19  10010

输出df2：

       name  age    tel
a  xiaoming   17  10086
b  xiaogang   19  10010

输出df3：

     0    1   2   3  4  5
0   18  262  64  71  7  0
1   19  262  64  70  7  0
2   20  262  64  70  7  0
3   21  262  64  69  7  0

2. 切片和索引

数据df：

    W      X     Y    Z
a  18  71.49  7.60  996
b  19  70.26  7.56  326
c  20  70.68  7.72  521
d  21  69.31  7.69  218
e  22  66.90  7.84  448

注：以下操作均以数据df为基础,自定义索引在3：DataFrame操作那一块

（1）常规（不推荐）：

>>> df[1:3] # 取连续的多行
    W      X     Y    Z
b  19  70.26  7.56  326
c  20  70.68  7.72  521

>>> df["Y"] # 取某列
a    7.60
b    7.56
c    7.72
d    7.69
e    7.84
Name: Y, dtype: float64

>>> df[["X", "Z"]] # 取不连续的多列
       X    Z
a  71.49  996
b  70.26  326
c  70.68  521
d  69.31  218
e  66.90  448

>>> df[1:3][["W", "Z"]] # 取多个不相邻的元素
    W    Z
b  19  326
c  20  521

注：常规的受限太多，不推荐使用

（2）优化：df.loc（通过标签获取行数据）：

>>> df.loc["a"] # 取某行
W     18.00
X     71.49
Y      7.60
Z    996.00
Name: a, dtype: float64

>>> df.loc["a":"d"] # 取连续的多行，左右均闭
    W      X     Y    Z
a  18  71.49  7.60  996
b  19  70.26  7.56  326
c  20  70.68  7.72  521
d  21  69.31  7.69  218

>>> df.loc[["a", "c", "e"]] # 取不连续的多行
    W      X     Y    Z
a  18  71.49  7.60  996
c  20  70.68  7.72  521
e  22  66.90  7.84  448

>>> df.loc[:, "Y"] # 取某列
a    7.60
b    7.56
c    7.72
d    7.69
e    7.84
Name: Y, dtype: float64

>>> df.loc[:, "W":"Y"] # 取连续多列
    W      X     Y
a  18  71.49  7.60
b  19  70.26  7.56
c  20  70.68  7.72
d  21  69.31  7.69
e  22  66.90  7.84

>>> df.loc[:, ["Z", "X"]] # 取不连续的多列
     Z      X
a  996  71.49
b  326  70.26
c  521  70.68
d  218  69.31
e  448  66.90

>>> df.loc["a", "X"] # 取一个元素
71.49

>>> df.loc["a":"c", "X":"Z"] # 取多个相邻的元素
       X     Y    Z
a  71.49  7.60  996
b  70.26  7.56  326
c  70.68  7.72  521

>>> df.loc[["a", "c"], ["X", "Z"]] # 取多个不相邻的元素
       X    Z
a  71.49  996
c  70.68  521

（3）优化：df.iloc（通过位置获取行数据）：

>>> df.iloc[1] # 取某行
W     19.00
X     70.26
Y      7.56
Z    326.00
Name: b, dtype: float64

>>> df.iloc[0:3] # 取连续的多行，左闭右开
    W      X     Y    Z
a  18  71.49  7.60  996
b  19  70.26  7.56  326
c  20  70.68  7.72  521

>>> df.iloc[[1, 3, 4]] # 取不连续的多行
    W      X     Y    Z
b  19  70.26  7.56  326
d  21  69.31  7.69  218
e  22  66.90  7.84  448

>>> df.iloc[:, 1] # 取某列
a    71.49
b    70.26
c    70.68
d    69.31
e    66.90
Name: X, dtype: float64

>>> df.iloc[:, 1:4] # 取连续多列
       X     Y    Z
a  71.49  7.60  996
b  70.26  7.56  326
c  70.68  7.72  521
d  69.31  7.69  218
e  66.90  7.84  448

>>> df.iloc[:, [1, 3, 0]] # 取不连续的多列
       X    Z   W
a  71.49  996  18
b  70.26  326  19
c  70.68  521  20
d  69.31  218  21
e  66.90  448  22

>>> df.iloc[1, 3] # 取一个元素
326

>>> df.iloc[1:4, 0:2] # 取多个相邻的元素
    W      X
b  19  70.26
c  20  70.68
d  21  69.31

>>> df.iloc[[1, 3, 0], [2, 0]] # 取多个不相邻的元素
      Y   W
b  7.56  19
d  7.69  21
a  7.60  18

（4）布尔索引

>>> df[df["Z"] > 500] # 输出Z列大于500的行
    W      X     Y    Z
a  18  71.49  7.60  996
c  20  70.68  7.72  521

>>> df[(df["Z"] > 300) & (df["Z"] < 900)] # 输出Z列大于300且小于900的行
    W      X     Y    Z
b  19  70.26  7.56  326
c  20  70.68  7.72  521
e  22  66.90  7.84  448

3. DataFrame的一些操作

数据df：

    0      1     2    3
0  18  71.49  7.60  996
1  19  70.26  7.56  326
2  20  70.68  7.72  521
3  21  69.31  7.69  218
4  22  66.90  7.84  448

注：以下操作均以数据df为基础

（1）自定义行列索引

df.index = list("abcde")
df.columns = list("WXYZ")
print(df)

输出df：

    W      X     Y    Z
a  18  71.49  7.60  996
b  19  70.26  7.56  326
c  20  70.68  7.72  521
d  21  69.31  7.69  218
e  22  66.90  7.84  448

（2）修改数据类型

df1 = df.astype("int")
print(df1)

输出df1：

    0   1  2    3
0  18  71  7  996
1  19  70  7  326
2  20  70  7  521
3  21  69  7  218
4  22  66  7  448

（3）按某列进行排序

df2 = df.sort_values(by=3)  # 按3列进行排序
print(df2)

输出df2：

    0      1     2    3
3  21  69.31  7.69  218
1  19  70.26  7.56  326
4  22  66.90  7.84  448
2  20  70.68  7.72  521
0  18  71.49  7.60  996

注：sort_values参数默认值如下：

    def sort_values(  # type: ignore[override]
        self,
        by,
        axis: Axis = 0, 
        ascending=True,  
        inplace: bool = False,
        kind: str = "quicksort",
        na_position: str = "last",
        ignore_index: bool = False,
        key: ValueKeyFunc = None,
    ):

（4）其他操作

print(df.index) # 行索引
print(df.columns) # 列索引
print(df.shape) # 形状
print(df.dtypes) # 各列的数据类型
print(df.ndim)  # 数据的维度
print(df.head(3)) # 显示数据的前3行，默认显示5行
print(df.tail(3)) # 显示数据的最后3行，默认显示5行
print(df.info()) # 展示df的各种信息
print(df.describe()) # 统计数据列的总数、均值、标准差、最小值、最大值、中位数等

4. 缺失值的处理

数据df：

    W      X     Y      Z
a  18  71.49  7.60  996.0
b  19    NaN  7.56    NaN
c  20  70.68  7.72  521.0
d  21  69.31   NaN  218.0
e  22  66.90  7.84  448.0

注：以下操作均以数据df为基础

（1）删除行：dropna()函数

>>> df.dropna(axis=0) # 当行中有NaN，便删除此行
    W      X     Y      Z
a  18  71.49  7.60  996.0
c  20  70.68  7.72  521.0
e  22  66.90  7.84  448.0

>>> df.dropna(axis=0, how="all") # 当一行全为NaN，才删除此行
    W      X     Y      Z
a  18  71.49  7.60  996.0
b  19    NaN  7.56    NaN
c  20  70.68  7.72  521.0
d  21  69.31   NaN  218.0
e  22  66.90  7.84  448.0

>>> df.dropna(axis=0, inplace=True) # inplace：原地修改df
>>> df
    W      X     Y      Z
a  18  71.49  7.60  996.0
c  20  70.68  7.72  521.0
e  22  66.90  7.84  448.0

注：dropna参数默认值如下：

    def dropna(
        self,
        axis: Axis = 0,
        how: str = "any",
        thresh=None,
        subset=None,
        inplace: bool = False,
    ):

（2）填充数据：fillna()函数

>>> df.fillna(100) # 填充固定值
    W       X       Y      Z
a  18   71.49    7.60  996.0
b  19  100.00    7.56  100.0
c  20   70.68    7.72  521.0
d  21   69.31  100.00  218.0
e  22   66.90    7.84  448.0

>>> df.fillna(df.mean()) # 所有列进行填充，填充列中非空数据的平均值
    W       X     Y       Z
a  18  71.490  7.60  996.00
b  19  69.595  7.56  545.75
c  20  70.680  7.72  521.00
d  21  69.310  7.68  218.00
e  22  66.900  7.84  448.00

>>> df["Z"].fillna(df["Z"].mean()) # 某一列进行填充，填充列中非空数据的平均值
a    996.00
b    545.75
c    521.00
d    218.00
e    448.00
Name: Z, dtype: float64

5. 分组：groupby()函数

数据：

df = pd.DataFrame({
    'a': range(7),
    'b': range(7, 0, -1),
    'c': ["one", "one", "one", "two", "two", "two", "two"],
    'd': list("hjklmno")
})

（1）根据某列进行分组

grouped = df.groupby(by="c")  # 根据c列进行分组

注：分组后的数据类型为：DataFrameGroupBy

（2）查看分组后的数据组成

>>> for each in grouped:
...     print(each)
...     break
... 
('one',    a  b    c  d
0  0  7  one  h
1  1  6  one  j
2  2  5  one  k)

注：每组数据为一个元组，第一个元素为组名，第二个元素为属于该组的数据（DataFrame类型）

（3）输出组名和数据：

>>> for each in grouped:
...     print(each[0])
...     break
one

注：print(each[1])可以输出对应该组的数据

6. 简单索引和复合索引

数据：

df = pd.DataFrame({
    'a': range(7),
    'b': range(7, 0, -1),
    'c': ["one", "one", "one", "two", "two", "two", "two"],
    'd': list("hjklmno")
})

（1）简单索引

① 设置某列为索引：

>>> df.set_index("c", inplace=True)  # 设置c列为索引，inplace：在原数据上直接修改
>>> df
     a  b  d
c           
one  0  7  h
one  1  6  j
one  2  5  k
two  3  4  l
two  4  3  m
two  5  2  n
two  6  1  o

② 根据索引取值：

>>> df.loc["one"]   # loc:通过标签取行，取出索引为one的行
     a  b  d
c           
one  0  7  h
one  1  6  j
one  2  5  k

（2）复合索引

① 设置多列为索引：

>>> df.set_index(["c", "d"], inplace=True)  # 设置c d两列为复合索引
>>> df
       a  b
c   d      
one h  0  7
    j  1  6
    k  2  5
two l  3  4
    m  4  3
    n  5  2
    o  6  1

② 取出索引c为“one”的数据：

>>> df.loc["one"]
   a  b
d      
h  0  7
j  1  6
k  2  5

③ 取出c列为”one“，d列为”h“的行：

>>> df.loc["one"].loc["h"]
a    0
b    7

④ 交换索引列：

>>> df.swaplevel(0,2)   # 将第0级索引与第2级索引进行交换：索引a与索引c交换
         b
a d c     
0 h one  7
1 j one  6
2 k one  5
3 l two  4
4 m two  3
5 n two  2
6 o two  1

三、时间序列

1. 创建时间序列

（1）date_range()

data_range = pd.date_range(start="20221225", end="20221229", freq="D")  # 指定开始和结束时间
data_range1 = pd.date_range(start="20221225", periods=5, freq="D")  # 指定开始时间和时间序列个数

输出：

>>> data_range
DatetimeIndex(['2022-12-25', '2022-12-26', '2022-12-27', '2022-12-28',
               '2022-12-29'],
              dtype='datetime64[ns]', freq='D')           
>>> data_range1
DatetimeIndex(['2022-12-25', '2022-12-26', '2022-12-27', '2022-12-28',
               '2022-12-29'],
              dtype='datetime64[ns]', freq='D')

（2）PeriodIndex()

原始数据：

>>> df
       year  month  day  hour
0      2010      1    1     0
1      2010      1    1     1
2      2010      1    1     2
3      2010      1    1     3
4      2010      1    1     4

period = pd.PeriodIndex(year=df["year"], month=df["month"], day=df["day"], hour=df["hour"], freq="H")

处理后的数据：

>>> period
PeriodIndex(['2010-01-01 00:00', '2010-01-01 01:00', '2010-01-01 02:00',
             '2010-01-01 03:00', '2010-01-01 04:00', '2010-01-01 05:00',
             '2010-01-01 06:00', '2010-01-01 07:00', '2010-01-01 08:00',
             '2010-01-01 09:00',
             ...

四、补充

1. 数组的合并----list类型

数据：

a = [1, 3, 5]
b = [2, 4, 6, 7]

（1）使用“＋”号

>>> a + b
[1, 3, 5, 2, 4, 6, 7]

（2）extend()函数

>>> a.extend(b)
>>> a
[1, 3, 5, 2, 4, 6, 7]

（3）列表表达式

>>> c = [a, b]
>>> d = [i for _c in c for i in _c]
>>> d
[1, 3, 5, 2, 4, 6, 7]

2. 字典中添加新字段

数据：

>>> dict = {"a": [], "b": [], "c": []}
>>> dict
{'a': [], 'b': [], 'c': []}

（1）添加字段：update()函数

>>> dict.update({"new": []})
>>> dict
{'a': [], 'b': [], 'c': [], 'new': []}

3. DataFrame类型数据保存为CSV文件

def dfToCSV(file_name, col_name, data):
    import csv
    with open(file_name+".csv", "w", encoding="gbk", newline="") as f:
        # 2. 基于文件对象构建 csv写入对象
        csv_writer = csv.writer(f)
        # 3. 构建列表头
        csv_writer.writerow(col_name)
        # 4. 写入csv文件内容
        for i in range(data.shape[0]):
            csv_writer.writerow(data.iloc[i])
        print("写入数据成功")
        # 5. 关闭文件
        f.close()