代码收藏家技术教程 2025-02-17

python-pandas自学

1. 概述

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，用于数据分析。已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具。pandas是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具，也是一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算），可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据，可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据

2. 安装

pip install pandas -i https://mirrors.huaweicloud.com/repository/pypi/simple

3. 内置数据结构

3.1 Series

带标签的一维数组，能够存储各种数据类型

3.1.1 创建Series

pandas.Series(data, index, dtype, copy)

# data：一组数据

# index：数据索引标签，默认从0开始

# dtype：数据类型，会自动判断

# copy：是否data进行拷贝，默认False

import pandas as pd

# 创建空对象
ser_1 = pd.Series()
print(ser_1)

# 列表创建
ser_2 = pd.Series([1,2,3,4,5])
print(ser_2)

# ndarray创建
ser_3 = pd.Series(data=np.array(['mc','jw','ly']))
print(ser_3)

# 字典创建
ser_4 = pd.Series(data={'name':'mc','gender':'female'})
print(ser_4)

# 标量创建
ser_5 = pd.Series(data=5,index=[1,2,3,4,5])    # 这里如果index省略的话，只会创建一行
print(ser_5)

3.1.2 访问Series

import pandas as pd

data = {'name': 'mc', 'gender': 'female'}
ser = pd.Series(data=data)
print(ser["name"])
print(ser[1])

3.1.3 常用属性

import pandas as pd

ser = pd.Series([1, 2, 3, 4, 5])

print("以列表的形式返回所有行索引标签：", ser.axes)
print("返回对象的数据类型：", ser.dtype)
print("返回一个布尔值，用于判断数据对象是否为空", ser.empty)
print("返回输入数据的维数：", ser.ndim)
print("返回输入数据的元素数量：", ser.size)
print("以 ndarray 的形式返回 Series 对象：", ser.values)
print("返回一个 RangeIndex 对象，用来描述索引的取值范围：", ser.index)

3.1.4 常用方法

1. head() 和 tail()

import pandas as pd

ser = pd.Series(['mc', 'jw', 'ly', 'lxy', 'zy', 'lb'])
print("------------前5行------------")
print(ser.head())    # 这里head里面可以传打印的行数，默认是5
print("------------后5行------------")
print(ser.tail())

2. isnull() 和 notnull()

import pandas as pd

ser = pd.Series(['mc', 'jw', 'ly', 'lxy', None])
print("-------------null值-------------")
print(ser.isnull())
print("-------------非null值-------------")
print(ser.notnull())

print("-------------打印-------------")
print(ser[ser.notnull()])

3.2 DataFrame

二维表格型数据结构，也是异构数据结构，每列数据类型可以不同，其每行每列可看作带标签的Series结构

3.2.1 创建DataFrame

pandas.DataFrame(data, index, columns, dtype, copy)

# data：一组数据

# index：行标签

# columns：列标签

# dtype：数据类型

# copy：复制数据data，默认为False

import pandas as pd

# 创建空对象
df_1 = pd.DataFrame()
print(df_1)

# 列表创建
df_2 = pd.DataFrame(data=['mc', 'jw', 'ly', 'lxy'],columns='name')
print(df_2)

# 列表嵌套列表创建
data = [['A',1],['B',2],['C',3]]
df_3 = pd.DataFrame(data,columns=['name','age'],index=['a','b','c'])
print(df_3)

# 列表嵌套字典创建
data = [{'name':'mc', 'age':26}, {'name':'jw', 'age':25, 'gender':'female'}]
df_4 = pd.DataFrame(data=data)    # 若在此处指定列，会导致数据丢失
print(df_4)

# 字典创建
data = {'name':['mc', 'jw', 'ly'], 'age':[26, 25, 24]}
df_5 = pd.DataFrame(data=data)
print(df_5)

# Series创建
data = {1:pd.Series([1, 2, 3], index=['a', 'b', 'c']), 2:pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df_6 = pd.DataFrame(data=data)
print(df_6)

3.2.2 列索引操作

1. 选取数据

import pandas as pd

df = pd.DataFrame({'name':['A','B','C'],'age':[10,20,30],'id':[1,2,3]})

print(df['name'])

2, 添加数据

import pandas as pd

df = pd.DataFrame({'name':['A','B','C'],'age':[10,20,30]})

# 赋值添加
df['sex'] = ['male', 'female', 'male']

print(df)

# 通过assign函数添加
df = df.assign(id = [1, 2, 3])

# 通过insert(loc, column, value)方法
# loc：插入位置的列索引
# column：新列的名称
# value：要插入的值
df.insert(1, 'height', [170, 168, 165])
print(df)

3. 修改数据

import pandas as pd
import numpy as np

df = pd.DataFrame({'name':['A','B','C'],'age':[10,20,30]})

# 修改列值
df['age'] -= 5
print(df)

# 修改列名
df.columns = ['names', 'ages']
print(df)

# rename方法
df = df.rename(columns={'names':'name', 'ages':'age'})
print(df)

# 修改数据类型
df['age'] = df['age'].astype(np.float32)
print(df)

4. 删除数据

import pandas as np

# DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
# labels：删除的标签，若有index或columns则忽略
# axis：删除的方向，0/index表示行，1/columns表示列
# index：删除的行标签
# columns：删除的列标签
# level：删除的级别
# inplace：是否直接修改原DataFrame
# errors：如何处理不存在标签

df = pd.DataFrame()
df['F'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
df['S'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(df)

df1 = df.drop(['F'],axis=1)
print(df1)
print(df)
df.drop(['F'], axis=1, inplace=True)
print(df)

3.3.3 行索引操作

1. loc获取数据

import pandas as pd

# DataFrame.loc[row_indexer, column_indexer]
# row_indexer：行标签
# column_indexer：列标签

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

print(df.loc['a'])  # 选择行标签为 'a' 的行
print(df.loc['a':'c'])  # 选择行标签从 'a' 到 'c' 的行
print(df.loc['a', 'B'])  # 选择行标签为 'a'，列标签为 'B' 的元素
print(df.loc[['a', 'c'], ['A', 'C']])  # 选择行标签为 'a' 和 'c'，列标签为 ‘A’ 和 ‘C’ 的数据

2. iloc获取数据

import pandas as np

# DataFrame.iloc[row_indexer, column_indexer]
# 参数同loc相同

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

print(df.iloc[0])  # 选择第 0 行的数据
print(df.iloc[0:2])  # 选择第 0 到 1 行的数据
print(df.iloc[0, 1])  # 选择第 0 行，第 1 列的元素
print(df.iloc[[0, 2], [0, 2]])  # 选择第 0 和 2 行，第 0 和 2 列的数据

3. 切片选取

import pandas as pd

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

result = df[0:2]
print(result)

4. 添加新行

import pandas as pd

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

# pandas 1.4.0后被弃用
# DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=False)

# loc方法
df.loc['e'] = [17, 18, 19, 20]
print(df)

# pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
# objs：要连接的DataFrame或Series对象
# axis：连接的轴，0/index表示行，1/columns表示列
# join：连接方式，outer（并集、默认），inner（交集）
# ignore_index：是否忽略原始索引，生成新索引
# 以下参数了解即可
# keys：创建层次化索引
# levels：层次化索引级别
# names：层次化索引名称
# verify_integrity：是否检测有重复索引
# sort：是否进行排序
# copy：是否复制数据

df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
})

print(pd.concat([df1, df2], axis=0))

5. 删除行

import pandas as pd

data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
        'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df_del = df.drop('a')
print(df_del)

3.3.4 常用属性和方法

import pandas as pd

data = {"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}
df = pd.DataFrame(data=data, index=['a', 'b', 'c', 'd'])

print("行列转置后的数据\n", df.T)
print("行轴和列轴标签:", df.axes)
print("每列数据类型:", df.dtypes)
print("是否为空:", df.empty)
print("DataFrame的维度:", df.ndim)
print("DataFrame形状:", df.shape)
print("元素数量:", df.size)
print("元素值:", df.values)
print("前3行:\n", df.head(3))
print("后3行:\n", df.tail(3))

4. 常用函数

4.1 常用统计学函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

import pandas as pd

data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50],
    'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)

print("----------------每列均值----------------")
print(df.mean())

print("---------------每列中位数---------------")
print(df.median())

# 这里和numpy的方差不同，pandas计算的是样本方差
print("----------------每列方差----------------")
print(df.var())

print("---------------每列标准差---------------")
print(df.std())

print("---------------每列最小值---------------")
print(df.min())

print("---------------每列最大值---------------")
print(df.max())

print("----------------每列总和----------------")
print(df.sum())

print("---------------每列非空数---------------")
print(df.count())

4.2 重置索引

4.2.1 reindex

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

# labels：新的索引标签

# index：行索引

# columns：列索引

# axis：重新索引的轴，0/index为行，1/columns为列

# method：用于填充缺失值的方法，ffill：向前填充，bfill：向后填充

# copy：是否返回新的DataFrame或Series

# level：重新索引的级别

# fill_value：填充缺失值的值

# limit：连续填充的最大数量

# tolerance：重新索引的容差

import pandas as np

data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

df_1 = df.reindex(['a', 'b', 'c', 'd'])
print(df_1)

df_2 = df.reindex(columns=['A', 'B', 'C', 'D'])
print(df_2)

df_3 = df.reindex(['a', 'b', 'c', 'd'], method='ffill')
print(df_3)

df_4 = df.reindex(['a', 'b', 'c', 'd'], fill_value=0)
print(df_4)

4.2.2 reindex_like

DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

# other：对齐索引和列的参考对象

# method：填充缺失值的方法，ffill：向前填充，bfill：向后填充

# copy：是否返回新的DataFrame或Series

# limit：填充的最大数量

# tolerance：重新索引的容差

import pandas as pd

# 对齐行索引
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
}, index=['b', 'c', 'd'])

df_1 = df1.reindex_like(df2)
print(df_1)

# 对齐列索引
df3 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])

df4 = pd.DataFrame({
    'B': [7, 8, 9],
    'C': [10, 11, 12]
}, index=['a', 'b', 'c'])

df_2 = df3.reindex_like(df4)
print(df_2)

4.3 遍历

# Series遍历

import pandas as pd

# for循环直接遍历
ser1 = pd.Series([1, 2, 3, 4, 5])
for item in ser1:
    print(item, end=' ')

# items()
ser2 = pd.Series(['a', 'b', 'c'])
for index, value in ser2.items(():
    print(f"Index: {index}, Value: {value}")

# index属性
for index iin ser2.index:
    print(f"Index: {index}, Value: {ser2[index]}")

# values属性
for value in ser2.values:
    print("Value: ", value)

# DataFrame遍历

import pandas as pd

# 直接访问，输出列标签
df = pd.DataFrame({
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
})

for item in df:
    print(item, end=' ')

# iterrows()
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])

for index, row in df.iterrows():
    print(index)
    print(row)

# itertuples()  
# 此方法速度和内存使用上更加高效
for row in df.itertuples():    # 忽略索引 for row in df.itertuples(index=False):
    print(row)
    for i in row:
        print(i)


# items()
for col_name, col_data in df.items():
    print(col_name)
    print(col_data)

# 属性遍历
for index in df.index:
    for col in df.columns:
        print(f"Index: {index}, Column: {col}, Value: {df.loc[index, col]}")

4.4 排序

4.4.1 sort_index

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

# axis：排序的轴，0（按行），1（按列）

# ascending：是否为升序

# inplace：是否原地修改数据

import pandas as pd

data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])

df_1 = df.sort_index()

print(df_1)

df_2 = df.sort_index(axis=1, ascending=False)
print(df_2)

4.4.2 sort_values

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

# by：要排序的列

# axis：沿着哪个轴排序，0为行，1为列

# ascending：是否升序排列

# inplace：是否原地修改数据

# kind：排序算法
import pandas as pd

df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
})

df_1 = df.sort_values(by='Age')
print(df_1)

df_2 = df.sort_values(by=['Age', 'Score'])
print(df_2)

df_3 = df.sort_values(by='Age', ascending=False)
print(df_3)

df_4 = df.sort_values(by=['Age', 'Score'], ascending=[False, True])
print(df_4)
# na_position：缺失值的位置，first，last

4.5 去重

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

# by：标记重复项的列名，未指定，则使用所有列

# subset：指定列的子集

# keep：如何保存重复项，first，last，False

# inplace：是否原地修改数据

import pandas as pd

data = {
    'A': [1, 2, 2, 3],
    'B': [4, 5, 5, 6],
    'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)

df_1 = df.drop_duplicates()
print(df_1)

df_2 = df.drop_duplicates(keep='last')
print(df_unique)

4.6 分组

4.6.1 groupby

DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

# by：用于分组的列名

# axis：沿着哪个轴分组

# level：分组的MultiIndex的级别

# as_index：是否保留索引

# sort：是否进行排序

# group_keys：是否添加组键

# squeeze：是否返回一个元素

# observed：是否只考虑数据中出现的标签

import pandas as pd

data = {
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': [1, 2, 3, 4, 5, 6, 7, 8],
    'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)

# 按A分组
grouped = df.groupby('A')

# 打印
for name, group in grouped:
    print(f"Group: {name}")
    print(group)

# 每组平均值
mean = grouped['C'].mean()
print(mean)

# 给每组添加平均值
# transform用于分组操作中每组内数据进行转换，并将结果合并到原数据内
# 常用的有mean（平均值），std（方差）
mean = grouped['C'].transform('mean')
df['C_mean'] = mean
print(df)

# 获取每组的信息
bar = grouped.get_group('bar')
print(bar)

4.6.2 filter

主要作用：按条件过滤数据，一般搭配groupby使用，具体方法如下：

import pandas as pd

data = {
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': [1, 2, 3, 4, 5, 6, 7, 8],
    'D': [10, 20, 30, 40, 50, 60, 70, 80]
}

df = pd.DataFrame(data)

df_f = df.groupby('A').filter(lambda x: x['C'].mean() >= 4)

print(df_f)

4.7 合并

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

# left：左侧对象

# right：右侧对象

# how：合并方式，inner（默认，内连接），outer（外连接），left（左连接），right（右连接）

# on：连接的列名

# left_on和right_on：左侧/右侧连接列名

# left_index和right_index：是否使用索引作为连接键

# sort：是否进行排序

# suffixes：指定当列名冲突，左侧和右侧DataFrame后缀

# copy：是否返回一个新的DataFrame

# indicator：是否添加一个名为__merge的列，内容为如何合并的

# validate：验证是否符合特定的模式

import pandas as pd

left = pd.DataFrame({
    'key':['k0', 'k1', 'k2', 'k3'],
    'A':['A0', 'A1', 'A2', 'A3'],
    'B':['B0', 'B1', 'B2', 'B3']
})

right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})

# 内连接
con_1 = pd.merge(left, right, on='key')

print(con_1)

# 左连接
con_2 = pd.merge(left, right, on='key', how='left')

print(con_2)

4.8 时间

4.8.1 datetime

'''
datetime模块并非pandas自带的模块，而是python自带的模块，所以仅介绍怎么使用
'''

from datetime import datetime

dt = datetime(2024, 5, 19, 16, 45, 30)
print(dt)
print(dt.date())
print(dt.time())

# 当前时间
print(datetime.now())

4.8.2 Timestamp

pandas.Timestamp(time, unit, tz)

# time：具体的时间或者时间戳

# unit：时间戳的单位

# tz：时区

import pandas as pd

ts_1 = pd.Timestamp(1739156800, unit='s', tz='Asia/Shanghai')
print(ts_1)

ts_2 = pd.Timestamp(1739156800100, unit='ms', tz='Asia/Chongqing')
print(ts_2)

4.8.3 日期解析

pandas.to_datetime(date_str)

# date_str：日期时间

import pandas as pd

date_obj = pd.to_datetime('2023-10-01')
print(date_obj)

4.8.4 date_range

pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)

# start：起始日期时间

# end：结束日期时间

# periods：生成的日期时间索引的数量，一般仅搭配start使用，不需要添加end

# freq：时间频率，‘D’（天），‘h’（小时），‘T’ / ‘min’（分钟），‘S’（秒）

# tz：时区

# normalize：是否归一化到午夜

# name：日期时间索引的名称

# closed：指定是否包含起止时间

import pandas as pd

dt = pd.date_range('2025-01-01', '2025-01-10', freq='D')
print(dt)

dt = pd.date_range(start='2025-02-10', freq='h', periods=5)
for date in dt:
    print(date)

4.8.5 时间差

import pandas as pd

# 使用字符串建立
td_1 = pd.Timedelta('1 days 2 hours 30 minutes')
print(td_1)

# 使用参数建立
td_2 = pd.Timedelta(days=1, hours=2, minutes=30)
print(td_2)

# 使用整数和单位建立
td_3 = pd.Timedelta(5, unit='days')
print(td_3)

# 具体使用
td = pd.Timedelta(days=1, hours=2, minutes=3)
dt_1 = pd.Timestamp('2025-02-10') + td_1
print(dt_1)

dt_2 = datetime(2024, 5, 19, 16, 45, 30)
dt_2 += td_3

4.8.6 时间日期格式化

from datetime import datetime

date = datetime(2025, 2, 10, 17, 24, 30)

date_str = date.strftime("%Y-%m-%d %H:%M:%S")

print(date_str)

date_p = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")

print(date_p)


'''
%y：两位数的年份
%Y：四位数的年份
%m：月份
%d：天数
%H：24小时制的小时数
%I：12小时制的小时数
%M：分钟数
%S：秒数
'''

4.9 随机抽样

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

# n：抽取的行数

# frac：抽取的比例

# replace：是否放回抽样数据

# weights：权重值

# random_state：随机状态，None为不重复，1为可重复

# axis：哪个方向抽取，0为行，1为列

import pandas as pd

df = pd.DataFrame({
    "company": ['百度', '阿里', '腾讯'],
    "salary": [43000, 24000, 40000],
    "age": [25, 35, 49]
})

# 随机选两行
print(df.sample(n=2, axis=0))

# 随机选一列
print(df.sample(n=1, axis=1))

# 选取一半
print(df.sample(axis=0, frac=0.5))

4.10 空值处理

4.10.1 检测空值

import pandas as pd
import numpy as np

data = {
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)

# 检测空值
print(df.isnull())

# 检测非空值
print(df.notnull())

4.10.2 填充空值

import pandas as pd
import numpy as np

data = {
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
}

df = pd.DataFrame(data)

print(df.fillna(0))    # 这里面的参数可以是其他的，代表用来填充空值的值

4.10.3 删除空值

import pandas as pd
import numpy as np

data = {
    'A': [1, 2, np.nan, 4]
    'B': [5, np.nan, np.nan, 8]
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)

print(df.dropna())    # 默认axis=0，代表删除有空值的行

print(df.dropna(axis=1))    # axis=1，代表删除有空值的列

5. 读取文件

5.1 to_csv()

import pandas as pd

data = {
    'Name': ['mc', 'jw', 'ly'],
    'Age': [26, 25, 24],
    'City': ['ShangHai', 'SuZhou', 'XuZhou']
}

df = pd.DataFrame(data)
df.to_csv('data.csv', index=False)    # 若不加index=False，会将行索引作为单独一列存储

5.2 read_csv()

import pandas as pd

df = pd.read_csv('data.csv')
print(df)

6. 绘图

import pandas as pd
import matplotlib.pyplot as plt

data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)

# 柱状图
df.plot(kind='bar')
plt.show()

# 折线图
df.plot(kind='line')
plt.show()

# 直方图
df['A'].plot(kind='hist')
plt.show()

# 散点图
df.plot(kind='scatter', x='A', y='B')
plot.show()

# 饼图
series = pd.Series({
    'A': 10,
    'B': 20,
    'C': 30,
    'D': 40
})

series.plot(kind='pie', autopct='%1.1f%%')
plt.show()

作者：Seven·Yi

物联沃分享整理
物联沃-IOTWORD物联网 » python-pandas自学