Numpy、Matplotlib、Pandas方法

NumPy的大部分代码都是用C语言写的，其底层算法在设计时就有着优异的性能，这使得NumPy比纯Python代码高效得多

NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

一、Numpy

1.1安装

我使用的是windows系统利用python自带的pip这个功能在cmd中输入pip install numpy等待一段时间即可。或者说：“在网站上下载‘

Numpy中的数组类型，numpy在运算中数组运算优于列表list容器。

numpy中的ndarray是一个多维的数组对象：包含实际的数据，描述数据的元数据
大部分的数组操作仅仅是修改原数组部分，不改变底层的实际数据。

我们可以直接将数组看作一种新的数据类型，就像list、tuple、dict一样，但数组中所有元素的类型必须是一致的，Python支持的数据类型有整型、浮点型以及复数型，但这些类型不足以满足科学计算的需求，因此NumPy中添加了许多其他的数据类型，如bool、inti、int64、float32、complex64等。同时，它也有许多其特有的属性和方法。

元数据主要是描述数据属性（property）的信息，用来支持如指示存储位置、历史数据、资源查找、文件纪录等功能。其最本质、最抽象的定义为：data about data ，是一种广泛存在的现象，在许多领域有其具体的定义和应用。

import numpy as np将numpy重新命名为np

1.2方法总简单说明作用：

1.创建数组：
np.array()：从列表、元组或其他可迭代对象创建数组。
np.zeros()：创建一个指定形状的零数组。
np.ones()：创建一个指定形状的全1数组。
np.eye()：创建一个单位矩阵。
np.random.random()：创建一个指定形状的随机数数组。
np.linspace()：在指定范围内创建一组等间隔的数字。
np.arange()：在指定范围内创建一组等间隔的数字。

2.数组操作：
np.reshape()：将数组重塑为指定形状。
np.concatenate()：连接两个或多个数组。
np.split()：将数组分割成多个子数组。
np.transpose()：转置数组。
np.sort()：对数组进行排序。
np.argmax()：返回数组中最大值的索引。
np.argmin()：返回数组中最小值的索引。

3.数学运算：
np.add()：对两个数组进行逐元素相加。
np.subtract()：对两个数组进行逐元素相减。
np.multiply()：对两个数组进行逐元素相乘。
np.divide()：对两个数组进行逐元素相除。
np.power()：将数组的每个元素提高到指定的幂。
np.exp()：计算数组中每个元素的指数。
np.log()：计算数组中每个元素的自然对数。

4.统计方法：
np.mean()：计算数组的平均值。
np.std()：计算数组的标准差。
np.var()：计算数组的方差。
np.max()：返回数组中的最大值。
np.min()：返回数组中的最小值。
np.median()：计算数组的中位数。
np.percentile()：计算数组的百分位数。

5.线性代数：
np.dot()：计算两个数组的点积。
np.linalg.det()：计算矩阵的行列式。
np.linalg.eig()：计算矩阵的特征值和特征向量。
np.linalg.inv()：计算矩阵的逆。
np.linalg.norm()：计算矩阵的范数。
np.linalg.solve()：解线性方程组。

6.逻辑运算：
np.logical_and()：对两个数组进行逐元素逻辑与操作。
np.logical_or()：对两个数组进行逐元素逻辑或操作。
np.logical_not()：对数组进行逐元素逻辑非操作。
np.where()：根据条件从两个数组中返回元素。

7.其他方法：
np.unique()：返回数组中的唯一元素。
np.sum()：计算数组的总和。
np.prod()：计算数组的乘积。
np.any()：如果数组中有任何元素为True，则返回True。
np.all()：如果数组中的所有元素都为True，则返回True。
np.isnan()：对于数组中的每个NaN值返回True。
np.isinf()：对于数组中的每个无穷大值返回True。

hstack(tup)，参数是一个元组 vstack不同的是，vstack将数组进行纵向合并c = np.hstack((a, b))

np.split(a, 2, axis=1)

带上另外一个库可以看到图形：更直观了

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 256)
y = np.sin(x**3)

plt.plot(x, y)
plt.show()

import matplotlib.pyplot as plt

x_values = range(100)
y_values = [((x / 100) - 0.5) ** 3 for x in x_values]

plt.plot(x_values, y_values)

plt.title('Cubic Plot')
plt.show()

1.2 NumPy可以与许多科学计算库兼容，一些包括：

• SciPy（提供额外的数学函数和优化工具）
• Matplotlib（用于创建可视化和绘图）
• Pandas（用于数据操作和分析）
• Scikit-learn（机器学习库）
• TensorFlow（深度学习库）

使用NumPy创建了x数组作为自变量的值，用np.sin()函数计算y数组的相应的值，然后使用Matplotlib的plt.plot()函数将这些值绘制为线性图。最后，您使用 plt.show()来显示图形。所以，在这个例子中，NumPy和Matplotlib确实成功配合使用了。

1.3一般处理矩阵方法

#逐元素相乘 *
print(A * B)
print(np.multiply(A, B))

#内积运算 点乘（.）
x=np.dot(a,b,None)

激活函数是一种在神经网络中常用的函数，用于将输入信号转换为输出信号。在神经网络中，每个神经元都有一个激活函数，它将输入信号加权求和后，通过激活函数进行非线性变换，得到输出信号。这个过程可以看作是神经元的“激活”，因此这个函数被称为激活函数。
def关键字来定义一个函数，该函数将接受输入并返回输出。这是因为激活函数需要将输入映射到输出，而自定义函数可以让您更灵活地控制这种映射。
sigmoid函数
sigmoid函数是一种常用的激活函数，它将输入值映射到0到1之间的值。sigmoid函数的输出形状与输入形状相同，即对于任意形状的输入，sigmoid函数的输出形状也相同。sigmoid函数的定义如下：

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

relu函数
relu函数是一种常用的激活函数，它将所有小于0的元素替换为0，而大于等于0的元素保持不变。relu函数的输出形状也与输入形状相同，即对于任意形状的输入，relu函数的输出形状也相同。relu函数的定义如下：

> def relu(x):
>     return np.maximum(0, x)

softmax函数
softmax函数是一种常用的激活函数，它将输入向量转换为概率分布。softmax函数的输出形状也与输入形状相同，即对于任意形状的输入，softmax函数的输出形状也相同。softmax函数的定义如下：

def softmax(x):
    return np.exp(x) / np.sum(np.exp(x))

1.4应用

import numpy as np

def sigmoid(x):
    """
    sigmoid函数的输出是将输入x应用于sigmoid函数的结果，sigmoid函数定义为1 / (1 + exp(-x))
    """
    return 1 / (1 + np.exp(-x))

def relu(x):
    """
    relu函数的输出是将输入x应用于修正线性单元函数的结果，修正线性单元函数定义为np.maximum(0, x)
    """
    return np.maximum(0, x)

def softmax(x):
    """
    softmax函数的输出是将输入x应用于softmax函数的结果，softmax函数定义为np.exp(x) / np.sum(np.exp(x))
    """
    return np.exp(x) / np.sum(np.exp(x))

# 测试代码
X = np.array([[1, 2, 3], [4, 5, 6]])
print(f"Shape of input X: {X.shape}")
print(f"Shape of sigmoid output: {sigmoid(X).shape}")
print(f"Shape of relu output: {relu(X).shape}")
print(f"Shape of softmax output: {softmax(X).shape}")

1.5 nan

在NumPy中，nan（Not a Number）通常表示缺失值或无效的数值。当你读取本地文件并将其解释为NumPy数组时，如果文件中包含缺失值（例如，空值或None），NumPy会将这些缺失值表示为nan。

例如，如果你使用numpy.genfromtxt等函数读取包含缺失值的文件，NumPy会将缺失值替换为nan。

import numpy as np

# 从文件读取数据，缺失值将被替换为nan
data = np.genfromtxt('your_file.csv', delimiter=',')

解决：替换、插补

处理nan的方法可以使用np.nan_to_num函数将其替换为指定值（列的1中位，平均值），也可以使用np.isnan函数判断后转化为None来处理，或者直接删除含有nan的数据。这样做可以避免在数据处理过程中报错或者出现意外的结果。

GPT给的解决：最好是循环来

处理NumPy数组中的nan值通常涉及到数据清洗和填充缺失值。

1. 检测并删除nan值：

   import numpy as np
   
   data = np.array([[1.0, 2.0, np.nan],
                    [4.0, np.nan, 6.0]])
   
   # 删除包含nan的行
   cleaned_data = data[~np.isnan(data).any(axis=1)]
   

2. 填充nan值：

   import numpy as np
   
   data = np.array([[1.0, 2.0, np.nan],
                    [4.0, np.nan, 6.0]])
   
   # 用特定值填充nan
   filled_data = np.nan_to_num(data, nan=0.0)
   

   或者，你可以使用平均值、中位数等来填充nan：

   # 用列的均值填充nan
   col_means = np.nanmean(data, axis=0)
   data[np.isnan(data)] = np.take(col_means, np.isnan(data).nonzero()[1])
   

3. 插值：
   使用插值方法，如线性插值，根据已知的数据点来估算缺失值：

   import numpy as np
   from scipy.interpolate import interp1d
   
   data = np.array([[1.0, 2.0, np.nan],
                    [4.0, np.nan, 6.0]])
   
   # 线性插值
   interp = interp1d(np.arange(data.shape[1]), data, kind='linear', axis=1, fill_value="extrapolate")
   interpolated_data = interp(np.arange(data.shape[1]))
   

选择哪种方法取决于你的数据和分析需求。清洗和处理缺失值时，确保你的方法不会引入不良影响，并且要根据具体情况调整。

二、Matplotlib

Matplotlib是一个用于在Python中创建静态、交互式和动画可视化的Python库。

它对于需要以编程方式创建2D图表和图形的数据科学家和分析师特别有用。

import matplotlib.pyplot as plt

# 设置Matplotlib支持中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体为黑体
plt.rcParams['axes.unicode_minus'] = False  # 解决保存图像时负号'-'显示为方块的问题

plt.figure(figsize=(10, 5))
plt.title('标题')
plt.xlabel('横轴')
plt.ylabel('纵轴')
plt.plot([1, 2, 3], [1, 2, 3])
plt.show()

2.1.0 初步

画布（Figure）：plt.figure（）
绘图、坐标系axes：plt.subplots（）

import matplotlib.pyplot as plt
# 创建画布
##  大小，清晰度
plt.figure(figsize(8,6),dpi=100)
# 折线图
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
# 保存图片
plt.savefig('img/line_chart.png')
# 显示图形
plt.show()

plt.show()会释放figure资源，如果在显示图像之后保存图片将只能保存空图片。

2.1 matplotlib.pyplot 模块plt

2.1.1 自定义刻度

# x:要显示的刻度值
plt.xticks(x, **kwargs)
# y:要显示的刻度值
plt.yticks(y, **kwargs)

import random
import matplotlib.pyplot as plt

x=range(100)
y =[random.uniform(1,30) for i in x]

# 修改xy刻度
plt.xticks(range(0,100,10))
plt.yticks(range(0,20,2))
plt.plot(x,y)

plt.show()

2.1.2网格效果

plt.grid(True,linestyle='--',alpha=0.5)

plt.grid(True,linestyle='--',axis='y')

区别：

plt.grid(True, linestyle='--', alpha=0.5) 和 plt.grid(True, linestyle='--', axis='y') 这两行代码都是用来在Matplotlib的图表中添加网格线的，但它们各自的参数控制了网格线的不同方面：

1. plt.grid(True, linestyle='--', alpha=0.5)：

• True 表示启用网格线。
• linestyle=‘–’ 指定网格线的样式为虚线。
• alpha=0.5 设置网格线的透明度为半透明，alpha 的值范围是0到1，其中0是完全透明，1是完全不透明。

2. plt.grid(True, linestyle='--', axis='y')：

• True 同样表示启用网格线。
• linestyle=‘–’ 同样指定网格线的样式为虚线。
• axis=‘y’ 表示仅在y轴方向添加网格线，不在x轴方向添加。

简而言之，第一行代码在图表中添加了透明度为0.5的虚线网格线，覆盖了x轴和y轴方向。而第二行代码只在y轴方向添加了虚线网格线，没有设置透明度，所以网格线将是默认的不透明度。

2.1.3 plt.plot多折线样式

color参数可以改变颜色
linestyle可以改变线条风格
labe参数配合plt.legend()l用于显示图例

x=range(100)
y =[random.uniform(1,30) for i in x]
y2=[random.uniform(20,30) for i in x]

# 修改xy刻度#
plt.xticks(range(0,100,10))
plt.yticks(range(0,20,2))
#
plt.plot(x,y,color='r')
plt.plot(x,y2,color='g')

plt.legend(loc=1)中的loc参数控制显示图例位置

# plt.legend(loc=1)
- 'best': 0 - 自动选择最佳位置
- 'upper right': 1 - 图的右上角
- 'upper left': 2 - 图的左上角
- 'lower left': 3 - 图的左下角
- 'lower right': 4 - 图的右下角
- 'right': 5 - 图的右侧
- 'center left': 6 - 图的左侧中间位置
- 'center right': 7 - 图的右侧中间位置
- 'lower center': 8 - 图的底部中间位置
- 'upper center': 9 - 图的顶部中间位置
- 'center': 10 - 图的中心

plt.subplots() 函数用于创建一个图形和一组子图。

plt.函数名()相当于面向过程的画图方法，axes.set_方法名()相当于面向对象的画图方法。

fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(10, 5),dpi=100)

# Configure the first subplot
axes[0].set(title='First Plot', xlabel='X-axis Label', ylabel='Y-axis Label')
axes[0].plot([1, 2, 3], [1, 4, 9])  
axes[0].set_yticks(range(0,40,3)

axes[0].set_xlabel("x"）
axes[0].set_ylabel("y")
axes[0].set_title("xxxx")
axes[1].plot(x)
# Show the plot
plt.show()

plt.函数名()和axes.set_方法名()都是用于绘制图形的方法，但是它们有一些不同之处。

plt.函数名()是面向过程的画图方法，它直接在当前图形对象上进行绘制操作。例如，plt.plot()会直接在当前图形对象上创建一个折线图。

而axes.set_方法名()是面向对象的画图方法，它需要先创建一个图形对象（通常是Axes对象），然后在该对象上进行绘制操作。例如，axes.set_xlabel()会在特定的Axes对象上设置x轴标签。

使用面向过程的方法，你不需要创建图形对象，可以直接在当前图形上进行绘制操作。这种方法适用于简单的绘图任务。使用面向对象的方法，你可以更灵活地控制图形的各个组成部分，并进行更复杂的绘图操作。

总的来说，plt.函数名()是一种便捷的绘图方式，适用于简单的绘图需求，而axes.set_方法名()则更适用于更灵活、更复杂的绘图需求。

2.2 图形种类

Matplotlib中常见的图形种类包括折线图、散点图、条形图、直方图、饼图等。

- 折线图：通过调用plt.show()可以显示绘制的折线图。

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

plt.plot(x, y)
plt.show()

plt.plot 是Matplotlib库中用于绘制折线图的函数。折线图用来显示变量随着另一个变量的变化而变化的趋势。

plt.plot(x, y, linestyle, marker, color)

其中，x和y分别是折线的x坐标和y坐标的数组，linestyle表示折线的样式，marker表示数据点的标记样式，color表示折线的颜色。

- 散点图：通过调用plt.show()可以显示绘制的散点图。

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

plt.scatter(x, y)
plt.show()

plt.scatter 是Matplotlib库中用于绘制散点图的函数。散点图用来显示两个变量之间的关系，其中每个点的位置表示两个变量的值。

plt.scatter(x, y, s=size, c=color, marker=marker)

其中，x和y分别是包含散点的x坐标和y坐标的数组，size表示散点的大小，color表示散点的颜色，marker表示散点的形状。

- 条形图：通过调用plt.show()可以显示绘制的柱状图。

import matplotlib.pyplot as plt

x = ['A', 'B', 'C', 'D', 'E']
y = [10, 20, 15, 25, 30]

plt.bar(x, y)
plt.show()

plt.bar 是Matplotlib库中用于绘制柱状图的函数。柱状图用于比较不同类别或组的数据，通过柱子的高度来表示数据的大小。

plt.bar(x, height, width=width, color=color)

其中，x是一个数组，包含每根柱子的位置信息，height是一个数组，包含每根柱子的高度，width是柱子的宽度，color是柱状图的颜色。

- 直方图：通过调用plt.show()可以显示绘制的直方图。

import matplotlib.pyplot as plt
import numpy as np

data = np.random.randn(1000)

plt.hist(data, bins=30)
plt.show()

plt.hist 是Matplotlib库中用于绘制直方图的函数。直方图用于显示数据的分布情况，将数据划分成多个区间（称为“箱子”），然后统计每个区间内数据的数量，最终以柱状图的形式展示。

plt.hist(x, bins=bins, color=color, alpha=alpha)

其中，x是输入的数据，bins用于指定箱子的数量或分布，color指定柱状图的颜色，alpha是指定柱状图的透明度。

- 饼图：通过调用plt.show()可以显示绘制的饼图。

import matplotlib.pyplot as plt

sizes = [15, 30, 45, 10]
labels = ['A', 'B', 'C', 'D']

plt.pie(sizes, labels=labels, autopct='%1.1f%%')
plt.show()

plt.pie 是Matplotlib库中用于绘制饼图的函数。它接受一组数值作为输入，然后根据这些数值的大小在饼图上绘制相应比例的扇形。

plt.pie(x, labels=labels, colors=colors, explode=explode, autopct='%1.1f%%', startangle=140)

其中，x是输入的数值，labels是扇形的标签，colors是扇形的颜色，explode是指定扇形的偏移量，autopct用于指定饼图上的数据标签格式，startangle是起始角度。

三、Pandas

pip install pandas 或者（根据需要选择方式）conda install pandas

Pandas 是一个开源的数据分析和数据处理库，建立在 NumPy 的基础上。它提供了一种灵活、高效、易用的数据结构，主要是 Series 和 DataFrame，用于处理和分析结构化数据。

3.1 介绍

1. 数据结构：
   • Series： 一维数组，类似于带有标签的 NumPy 数组，可以存储任意数据类型。
   • DataFrame： 二维表格，是 Pandas 最常用的数据结构，可以看作是由多个 Series 组成的字典。
   • Panel： 三维数组，已经逐渐被 MultiIndex DataFrame 替代，不过在某些特殊情况下仍然有用。

在最新的Pandas版本中（Pandas 1.0.0及更高版本），Panel类已被弃用并移除，因此会出现"module ‘pandas’
has no attribute
‘Panel’"的错误。Pandas现在更鼓励使用多层索引的DataFrame来表示三维数据，而不再使用Panel。
`
如果你之前的代码中使用了Panel，你需要修改代码以适应新的Pandas
API。将Panel对象替换为适当的DataFrame和多层索引的结构。

2. 数据操作：

   • Pandas 提供了丰富的数据操作功能，包括索引、切片、过滤、合并、排序等。
   • 支持对缺失数据的处理，提供灵活的插值和删除方法。
   • 提供了强大的分组和聚合功能，可以轻松地对数据进行分组统计。

3. 数据输入/输出：

   • Pandas 支持多种数据格式的输入和输出，包括 CSV、Excel、SQL 数据库、JSON、HTML 等。
   • 通过 Pandas，可以方便地将外部数据加载到 DataFrame 中，也可以将处理后的数据保存到不同的格式中。

Pandas 的这三大核心组件使其成为数据科学和分析中的重要工具，它的简洁性和高效性使得用户能够更轻松地处理和分析大规模数据集。

import pandas as pd

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}

df = pd.DataFrame(data)

# 打印DataFrame
print(df)

3.2 DataFrame 有列索引的二维数组

DataFrame 可以看作是一个二维表格，类似于电子表格或 SQL 表，其中数据以行和列的形式组织。

3.2.1 与 NumPy 的差别

1. 数据类型：

    NumPy 主要关注多维数组（ndarray），
    而 Pandas 更专注于表格型数据结构（DataFrame），适用于处理==异质数据==。
   

NumPy 是基于数组的库，而 Pandas 的 DataFrame 是基于表格的。
DataFrame 可以容纳不同数据类型的列，类似于数据库表格，而 NumPy 数组通常要求所有元素具有相同的数据类型。

2. 标签：

    NumPy 数组只有默认的整数索引，
    而 Pandas 的 Series 和 DataFrame 具有标签，==可以为数据添加索引==
   

DataFrame 支持列和行的标签，可以通过标签而不是索引来引用数据。这使得数据更加直观，尤其适合处理带有标签的数据。

3. 功能性： Pandas 提供了更高级的数据操作和分析功能，使得处理和分析数据的过程更为简便。DataFrame 的功能更适合数据科学和分析的需求。

在使用 Pandas 时，通常会同时使用 NumPy，因为 Pandas 是建立在 NumPy 的基础上的，二者结合使用可以更好地满足数据处理和分析的需求。

3.2.2 简单演示

import numpy as np
import pandas as pd
x = np.random.normal(0, 10, (10, 5))

pd.DataFrame(x)
# 添加行索引
line = ["line{}".format(i) for i in range(10)]
pd.DataFrame(x, index=line）
#添加列索引
col=["col{}".format(i) for i in range(5)]
print(col)

3.2.3 常见的属性和方法–组合使用用于查看、操作和分析数据。

（1）属性：

1. shape：

   • 描述：返回一个元组，表示 DataFrame 的行数和列数。
   • 示例：df.shape

2. columns：

   • 描述：返回包含 DataFrame 列名的索引对象。
   • 示例：df.columns

3. index：

   • 描述：返回包含 DataFrame 行标签的索引对象。
   • 示例：df.index

4. dtypes：

   • 描述：返回每列的数据类型。
   • 示例：df.dtypes

5. values：

   • 描述：返回 DataFrame 中的数据，以二维数组形式表示。
   • 示例：df.values;x.values.T

6. T：

   • 描述：返回 DataFrame 中的数据，以二维数组形式表示。
   • 示例：transposed_df = df.T;df = df.T

代码

import pandas as pd
import numpy as np

# 创建一个示例 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}

df = pd.DataFrame(data)
print(df)
# 查看 DataFrame 的基本信息
print("DataFrame Shape:")
print(df.shape)

print("\nColumn Names:")
print(df.columns)

print("\nIndex:")
print(df.index)

print("\nData Types:")
print(df.dtypes)

print("\nValues:")
print(df.values)

print("\nT:")
print(df.T)

（2）一般方法：

1. head(n)：

   • 描述：用于进行转置操作。转置操作是将 DataFrame 的行和列进行交换，即行变成列，列变成行
   • 示例：df.head()

2. tail(n)：

   • 描述：返回 DataFrame 的后 n 行，默认为后 5 行。
   • 示例：df.tail()

3. info()：

   • 描述：显示 DataFrame 的基本信息，包括列数据类型和非空值的数量。
   • 示例：df.info()

4. describe()：

   • 描述：生成关于 DataFrame 中数值列的统计摘要。
   • 示例：df.describe()

5. mean()、sum()、count() 等聚合方法：

   • 描述：对 DataFrame 列执行聚合操作。
   • 示例：df['ColumnName'].mean()

6. sort_values()：

   • 描述：按照指定列的值对 DataFrame 进行排序。
   • 示例：df.sort_values(by='ColumnName')

7. drop()：

   • 描述：删除指定的行或列。
   • 示例：df.drop('ColumnName', axis=1)

8. groupby()：

   • 描述：按照指定列进行分组。
   • 示例：df.groupby('ColumnName').mean()

9. apply()：

   • 描述：对 DataFrame 的元素应用函数。
   • 示例：df.apply(lambda x: x*2)

10. merge()：

    • 描述：合并两个 DataFrame。
    • 示例：pd.merge(df1, df2, on='CommonColumn')

11. pd.date_range

pd.date_range 的 start 参数需要提供一个有效的起始日期。以下是修正后的代码，并解释每个参数的作用：

# 生成一个 DatetimeIndex，起始日期为 '2024-01-01'，生成 5 个工作日（周一到周五），
#频率为工作日（Business Day）。 y =pd.date_range(start='2024-01-01', periods=5, freq='B') ```

1. **start：**
   - 描述：指定日期范围的起始日期。
   - 示例：`start='2024-01-01'`

2. **periods：**
   - 描述：生成的日期范围的长度，即要生成多少个日期。
   - 示例：`periods=5`

3. **freq：**
   - 描述：生成日期的频率。在这里，使用 'B' 表示工作日（Business Day），即从周一到周五的日期。
   - 示例：`freq='B'`

修正后的代码将生成一个包含 5 个工作日日期的 DatetimeIndex，起始日期为 '2024-01-01'，
并且每个日期都是工作日。

代码

import pandas as pd
import numpy as np

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}

df = pd.DataFrame(data)

# 创建一个文件对象并写入 DataFrame 的输出
with open('output.txt', 'w') as file:
    file.write("Original DataFrame:\n")
    file.write(str(df))

    file.write("\n\nHead of DataFrame:\n")
    file.write(str(df.head()))

    # 添加新列
    df['BirthYear'] = 2022 - df['Age']
    file.write("\n\nDataFrame after adding 'BirthYear' column:\n")
    file.write(str(df))

    # 描述性统计信息
    file.write("\n\nDescriptive Statistics:\n")
    file.write(str(df.describe()))

    # 按照年龄进行排序
    df_sorted = df.sort_values(by='Age')
    file.write("\n\nSorted DataFrame:\n")
    file.write(str(df_sorted))

    # 删除指定列
    df_cleaned = df.drop('City', axis=1)
    file.write("\n\nDataFrame after dropping 'City' column:\n")
    file.write(str(df_cleaned))

    # 分组计算平均值
    df_grouped = df[['Age']].groupby(df['City']).mean()
    file.write("\n\nGrouped DataFrame:\n")
    file.write(str(df_grouped))

    # 应用函数对年龄进行加倍
    df['AgeDoubled'] = df['Age'].apply(lambda x: x * 2)
    file.write("\n\nDataFrame with Doubled Age:\n")
    file.write(str(df))

3.2.4 索引

可以进行赋值操作

data.索引名 = 100
data.iloc[1, 0] = 222

（1）给numpy_array添加上行、列索引

# 添加行索引
line = ["line{}".format(i) for i in range(10)]
pd.DataFrame(x, index=line)

# 添加列索引
col=["col{}".format(i) for i in range(5)]
pd.DataFrame(x,index=line,columns=col)

import numpy as np
import pandas as pd

# 创建一个 NumPy 数组
numpy_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 转换为 Pandas DataFrame，并添加行列索引
df = pd.DataFrame(numpy_array, index=['Row1', 'Row2', 'Row3'], columns=['Col1', 'Col2', 'Col3'])
print(numpy_array)
print()
# 打印 DataFrame
print(df)

（2）修改索引：必须是整体上的修改

# (1)修改行列索引的值
x2=["str{}".format(i) for i in range(10)]


x.index=x2
#(2)重设索引
reset_index(drop=False)

#设置新的下标索引
#drop:默认为False,不删除原来索引,
#     如果为True,删除原来的索引值

（3）设置新的列索引

#设置新的列索引
m = n.set_index('a', drop=True)
print(m)
print(type(m))
print(m.index)
print(m.index.names)

m = n.set_index(['a','b'], drop=True)
print(m)
print(type(m))
print(m.index)
print(m.index.names)

表示某些对象的元数据或标签，以确保其不可变性。

（4）reset_index 和 set_index 是 Pandas 中用于处理 DataFrame 索引的两个重要方法。

reset_index 方法：

reset_index 方法用于重置 DataFrame 的行索引，将原来的行索引转为默认的整数索引，并将之前的行索引变成一列。该方法可以用来取消之前使用 set_index 设置的行索引。

import pandas as pd

# 创建一个DataFrame，并设置 'Name' 列为行索引
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}

df = pd.DataFrame(data)
df.set_index('Name', inplace=True)

# 使用 reset_index 方法重置行索引
df_reset = df.reset_index()

# 打印修改后的 DataFrame
print(df_reset)

set_index 方法：

set_index 方法用于设置 DataFrame 的行或列索引。可以指定一个或多个列作为新的索引，也可以在参数中使用 drop=False 保留原始列。

import pandas as pd

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}
        
df = pd.DataFrame(data)

# 使用 set_index 方法将 'Name' 列设置为行索引
df_set = df.set_index('Name')

# 打印修改后的 DataFrame
print(df_set)

这两个方法的使用场景通常涉及到对 DataFrame 索引的调整，根据具体需求选择合适的方法。reset_index 适用于将行索引还原为默认整数索引，而 set_index 则用于指定新的行或列索引。

3.3 Series 带索引的一维数组

在 Pandas 中，DataFrame 可以看作是 Series 对象的容器。

• Series： 是一维标记数组，可以包含不同数据类型的元素。Series 有索引（index）和数据（data）两个部分。DataFrame 中的每一列都是一个 Series。

• DataFrame： 是一个二维表格数据结构，可以看作是多个 Series 对象按列方向组合而成。DataFrame 有行索引（index）和列索引（columns），每列都是一个 Series。

所以，DataFrame 中的每一列都是一个 Series，而整个 DataFrame 就是多个 Series 的集合。这种组合使得 Pandas 能够方便地处理和分析表格型数据。

值得注意的是，在较新版本的 Pandas 中，Panel 已经被弃用。在最新的 Pandas 版本中，更推荐使用 MultiIndex DataFrame（多级索引的 DataFrame）来表示类似三维数据的结构，而不再使用 Panel。

3.3.1 创建Series

#指定内容，默认索引
pd.Series(np.arange[10])
#指定索引
pd.Series(np.arange[10],index=['a','b','c','d','e'])
#通过字典
pd.Series({'a':1,'b':2,'c':3})

import pandas as pd
import numpy as np

# 从列表创建 Series
data_list = [1, 3, 5, 7, 9]
series_from_list = pd.Series(data_list)
print("Series from list:")
print(series_from_list)
print("Type:", type(series_from_list))
print()

# 从 NumPy 数组创建 Series
data_array = np.array([10, 20, 30, 40, 50])
series_from_array = pd.Series(data_array)
print("Series from NumPy array:")
print(series_from_array)
print("Type:", type(series_from_array))
print()

# 指定索引创建 Series
data_dict = {'a': 100, 'b': 200, 'c': 300}
series_with_index = pd.Series(data_dict)
print("Series with index:")
print(series_with_index)
print("Type:", type(series_with_index))
print()

# 从标量值创建 Series
scalar_value = 5
series_from_scalar = pd.Series(scalar_value, index=['a', 'b', 'c', 'd'])
print("Series from scalar:")
print(series_from_scalar)
print("Type:", type(series_from_scalar))

3.3.2 获取索引和值 index和values

import pandas as pd

# 创建一个简单的 Series
data = [10, 20, 30, 40]
index = ['a', 'b', 'c', 'd']

series_data = pd.Series(data, index=index)

# 获取整个 Series
print("完整的 Series:")
print(series_data)

# 获取索引
print("\nSeries 的索引:")
print(series_data.index)

# 获取值
print("\nSeries 的值:")
print(series_data.values)

# 通过索引获取值
print("\n通过索引获取值:")
print("值 'b' 对应的数据:", series_data['b'])

print(type(series_data))

3.4 基本数据操作

3.4.1 索引操作

1. 直接索引：
   • 通过列名直接索引列数据，先列后行。df['ColumnName']

import pandas as pd
data=pd.read_csv("s.csv")
print(data["open"]["xxx"])

2. 按名字索引（使用 loc）：
   • 使用 loc 属性，可以根据行名和列名进行索引。 df.loc[row_label, column_label]或者
     df.loc[row_label] [column_label]（注意中括号）

import pandas as pd
data=pd.read_csv("s.csv")
# data.loc["xxx","open"]
data.loc["xxx"]["open"]

3. 按数字索引（使用 iloc）：
   • 使用 iloc 属性，可以根据行号和列号进行索引。 df.iloc[row_index, column_index]\

import pandas as pd
data=pd.read_csv("s.csv")
data.iloc[1,0]

4. 组合索引：
   • 在较新的版本中，不再使用 ix。推荐使用明确的 loc 和 iloc 进行混合索引。

代码

import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'San Francisco', 'Los Angeles']}

df = pd.DataFrame(data)

# 直接索引 - 先列后行
print("直接索引 - 先列后行:")
print("获取 'Age' 列的数据:")
print(df['Age'])

# 按名字索引 - loc
print("\n按名字索引 - loc:")
print("获取 'Bob' 的数据:")
print(df.loc[1, 'Name'])

# 按数字索引 - iloc
print("\n按数字索引 - iloc:")
print("获取第二行的数据:")
print(df.iloc[1])

# 组合索引 - 不再支持 ix（推荐使用 loc 或 iloc）
# 在较新的版本中，不再使用 ix，而是使用明确的 loc 和 iloc

# 示例：混合使用 loc 和 iloc
print("\n混合使用 loc 和 iloc:")
print("获取 'Alice' 的年龄:")
print(df.loc[df['Name'] == 'Alice', 'Age'].iloc[0])

3.4.1 排序

使用df.sort_values(by=, ascending=)对内容进行排序
单个键或者多个键进行排序，默认升序
ascending=False:降序
ascending=True :升序

（0）使用sort_values方法对DataFrame或Series进行排序

对DataFrame进行排序：

import pandas as pd

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 22, 30],
        'Salary': [50000, 60000, 75000]}

df = pd.DataFrame(data)

# 按某一列升序排序
df_sorted = df.sort_values(by='Age')

# 按某一列降序排序
df_sorted_desc = df.sort_values(by='Age', ascending=False)

print("按年龄升序排序：")
print(df_sorted)

print("\n按年龄降序排序：")
print(df_sorted_desc)

对Series进行排序：

import pandas as pd

# 创建一个Series
data = pd.Series([25, 22, 30], index=['Alice', 'Bob', 'Charlie'])

# 对Series进行升序排序
series_sorted = data.sort_values()

# 对Series进行降序排序
series_sorted_desc = data.sort_values(ascending=False)

print("升序排序：")
print(series_sorted)

print("\n降序排序：")
print(series_sorted_desc)

在这些示例中，sort_values方法可以接受参数 by，用于指定按照哪一列或索引进行排序。

默认情况下，排序是升序的，如果需要降序排序，可以通过设置参数 `ascending=False` 来实现。

（1）对内容排序：

数据排序在数据可视化中可以使数据更容易绘制成图表，展示趋势或者比较不同类别的数据。在数据筛选中，排序后可以更方便地根据某些条件筛选出特定的数据。
在数据清洗过程中，排序可以帮助发现异常值或不一致的数据，从而采取适当的措施。此外，在数据探索和分析中，排序可以帮助了解数据中的趋势、关系，找到最大或最小值。在合并不同的DataFrame或连接多个数据集时，排序索引可以确保正确匹配行，避免出现错误的合并结果。

【1】对 DataFrame 进行排序：

（1）按列排序：

import pandas as pd

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 22],
        'Score': [95, 89, 75]}

df = pd.DataFrame(data)
print(type(df))
# 按照 'Age' 列升序排序
print("\n ascending=False")
df_sorted = df.sort_values(by='Age',ascending=False)
print(df_sorted)

print("\n ascending=True")
df_sorted = df.sort_values(by='Age',ascending=True)

print(df_sorted)

（2）按多列排序：

# 按照 'Age' 列升序，然后按照 'Score' 列降序排序
df_sorted_multi = df.sort_values(by=['Age', 'Score'], ascending=[True, False])

print(df_sorted_multi)

【2】对 Series 进行排序：

（1）对 Series 进行排序

import pandas as pd
# 创建一个Series
series = pd.Series([25, 30, 22], index=['Alice', 'Bob', 'Charlie'])
print(type(series))
# 对 Series 进行升序排序
series_sorted = series.sort_values()
print(type(series_sorted))
print(series_sorted)

（2） DataFrame 中选取列，并按排序

import pandas as pd

# 创建一个DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 22],
        'Score': [95, 89, 75]}

df = pd.DataFrame(data)
print(type(df))
# 从 DataFrame 中选取 'Age' 列，并按升序排序
series_sorted = series.sort_values(ascending=False)
print(type(df_sorted_by_age))
print(df_sorted_by_age)

（2）对索引排序：使数据结构更有序。

数据分析中的数据排序对于确保数据分析的准确性和可视化的清晰性至关重要。按照特定顺序排序数据能够更好地理解数据趋势，比如处理时间序列数据时按时间顺序排序数据能更好地理解时间趋势。此外，在合并不同的DataFrame或连接多个数据集时，排序索引能确保正确匹配行，避免出现错误的合并结果。

【1】DataFrame

import pandas as pd

# 创建一个DataFrame
data = {'B': [4, 7, 1], 'A': [2, 5, 8]}
df = pd.DataFrame(data)

# 对行索引排序
df_sorted = df.sort_index(ascending=False)
print(df_sorted)

【2】Series

import pandas as pd

# 创建一个Series
data = {'B': 4, 'A': 2, 'C': 8}
series = pd.Series(data)

# 对索引排序
series_sorted = series.sort_index()
print(type(series_sorted))
print(series_sorted)

3.5 运算

3.5.1 普通的

import pandas as pd

# 创建两个DataFrame
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [7, 8, 9], 'B': [10, 11, 12]})

# 加法
result_add = df1 + df2
print("Addition:\n", result_add)

# 减法
result_subtract = df1 - df2
print("Subtraction:\n", result_subtract)

# 乘法
result_multiply = df1 * df2
print("Multiplication:\n", result_multiply)

# 除法
result_divide = df1 / df2
print("Division:\n", result_divide)

# 逻辑或
result_or = df1 | df2
print("Logical OR:\n", result_or)

# 逻辑与
result_and = df1 & df2
print("Logical AND:\n", result_and)

# 使用基本函数进行加法
result_func_add = df1.add(df2)
print("Function Addition:\n", result_func_add)

# 使用基本函数进行减法
result_func_subtract = df1.subtract(df2)
print("Function Subtraction:\n", result_func_subtract)

# 使用基本函数进行乘法
result_func_multiply = df1.multiply(df2)
print("Function Multiplication:\n", result_func_multiply)

# 使用基本函数进行除法
result_func_divide = df1.divide(df2)
print("Function Division:\n", result_func_divide)

3.5.2 逻辑运算符（| 和 &）举例是在选取相应的数据

import pandas as pd

# 创建一个DataFrame
data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8],
        'C': [9, 10, 11, 12]}

df = pd.DataFrame(data)

# 使用逻辑或选择满足任一条件的行
condition_or = (df['A'] > 2) | (df['B'] < 7)
result_or = df[condition_or]

print("Rows satisfying logical OR condition:\n", result_or)

# 使用逻辑与选择同时满足两个条件的行
condition_and = (df['A'] > 2) & (df['B'] < 8)
result_and = df[condition_and]

print("\nRows satisfying logical AND condition:\n", result_and)

Pandas提供了两种方便的方法来进行逻辑运算：query() 和 isin()

1. 使用 query() 进行逻辑运算：

query() 方法允许你使用类似SQL的语法来查询DataFrame。

import pandas as pd

# 创建一个DataFrame
data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8],
        'C': [9, 10, 11, 12]}

df = pd.DataFrame(data)

# 使用 query() 进行逻辑运算
result_query = df.query('(A > 2) & (B < 7)')
print("Rows satisfying logical conditions using query():\n", result_query)

在上述中，query('(A > 2) & (B < 7)') 选择了同时满足列’A’中大于2和列’B’中小于7的行。

2. 使用 isin() 进行逻辑运算：

isin() 方法用于过滤DataFrame中某列的值，以确保它们在指定的集合中。

import pandas as pd

# 创建一个DataFrame
data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8],
        'C': [9, 10, 11, 12]}

df = pd.DataFrame(data)

# 使用 isin() 进行逻辑运算
values_to_check = [3, 7]
result_isin = df[df['A'].isin(values_to_check)]
print("Rows where column 'A' is in the specified values:\n", result_isin)

在上述中，df['A'].isin(values_to_check) 选择了列’A’中的值在指定集合 [3, 7] 中的行。

3.5.3 函数

（1）数值列的描述性统计信息的函数 describe()

import pandas as pd

# 创建一个DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

# 使用describe()方法
summary = df.describe()
print(summary)

（2）其他常用的

min（最小值）、max（最大值）、mean（平均值）、median（中位数）、var（方差）和std（标准差）。

最大最小的位置
idxmax()，
idxmin()
在numpy中的上
np.argmax()
np.argmin()

axis=0 表示沿着列的方向计算。

# 使用.max(axis=0)方法
max_values = df.max(axis=0)
print(max_values)

（3）累计统计的函数。

1. cumsum(): 计算累积和。

   import pandas as pd
   
   df = pd.DataFrame({'A': [1, 2, 3, 4]})
   df['Cumulative_Sum'] = df['A'].cumsum()
   

2. cumprod(): 计算累积积。

   import pandas as pd
   
   df = pd.DataFrame({'A': [1, 2, 3, 4]})
   df['Cumulative_Product'] = df['A'].cumprod()
   

3. cummax() 和 cummin(): 分别计算累积最大值和累积最小值。

   import pandas as pd
   
   df = pd.DataFrame({'A': [1, 2, 3, 1, 4]})
   df['Cumulative_Max'] = df['A'].cummax()
   df['Cumulative_Min'] = df['A'].cummin()
   

4. cumcount(): 计算每组的元素累计计数。

   import pandas as pd
   
   df = pd.DataFrame({'A': [1, 1, 2, 2, 2, 3]})
   df['Cumulative_Count'] = df.groupby('A').cumcount() + 1
   

（4）图像

import pandas as pd

# 假设 df 是你的数据框
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

# 使用 Pandas 绘图
ax = df.plot()

# 在脚本中使用以下代码显示图表
ax.figure.show()

<pandas.plotting._core.PlotAccessor object at 0x000001E8A204C910>
实际上是一个对象的表示，而不是图表的实际内容。
要查看绘图的内容，你可以使用 show() 方法或在 Jupyter Notebook 中执行 %matplotlib inline来确保图表在输出中显示。

可以使用 plt.show() 来显示图像。请确保你的代码中已导入 matplotlib.pyplot 模块。

import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({'A': [1, 1, 2, 2, 2, 3]})
df['Cumulative_Count'] = df.groupby('A').cumcount() + 1

# 绘制图像
df['Cumulative_Count'].plot()
plt.show()

（5）自定义函数apply

pandas 中的 apply 函数用于在DataFrame的行或列上应用一个函数。

基本语法：

DataFrame.apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)

• func: 要应用的函数。
• axis: 指定应用函数的轴。0表示应用到列，1表示应用到行。
• raw: 如果为True，传递每个元素的Numpy数组。如果为False，传递Series对象。
• result_type: 指定返回的数据类型。默认为None。
• args: 传递给函数的其他参数。

示例：

import pandas as pd

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

示例1：对列应用自定义函数

def square(x):
    return x ** 2

df['A_squared'] = df['A'].apply(square)

这将创建一个新列 'A_squared'，其中包含列 'A' 中每个元素的平方。

示例2：对行应用自定义函数

def sum_of_row(row):
    return row['A'] + row['B']

df['Sum'] = df.apply(sum_of_row, axis=1)

这将创建一个新列 'Sum'，其中包含每行中列 'A' 和列 'B' 元素之和。

示例3：传递额外参数

def add_values(x, value):
    return x + value

df['A_plus_10'] = df['A'].apply(add_values, args=(10,))

这将创建一个新列 'A_plus_10'，其中包含列 'A' 中每个元素加上额外参数10的结果。

示例4：lambda

data.apply(lambda x: x.max() - x.min())

data["x1"].max() - data["x2"].min()

import pandas as pd

# 创建DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

# 对列应用lambda函数
df['A_squared'] = df['A'].apply(lambda x: x ** 2)

# 对行应用lambda函数
df['Sum'] = df.apply(lambda row: row['A'] + row['B'], axis=1)

# 打印结果
print(df)

在这个例子中，创建了一个包含列 ‘A’ 和列 ‘B’ 的DataFrame，然后使用 apply 函数应用了 lambda 函数，分别在列 ‘A’ 上进行平方运算和在每行上计算列 ‘A’ 和列 ‘B’ 的和。最后，打印出包含新列的DataFrame。

3.6 Pandas画图

data.plot(x="x1", y="x2", kind="scatter")
x: 指定 x 轴数据的列名或列索引。
y: 指定 y 轴数据的列名或列索引。
kind: 指定图表的类型，这里是散点图。

data.plot(x="x1", y="x2", kind="scatter")

data.plot(x="x3", y="x4", kind="scatter")

3.7 文件读取和存储

在Python中，Pandas库提供了一些用于读取和存储数据的功能，主要通过read_系列函数进行读取，以及to_系列函数进行存储。

3.7.1文件读取：

1. CSV文件：

   import pandas as pd
   df = pd.read_csv('file.csv')
   

import pandas as pd

# 读取CSV文件，只选择 "A" 和 "B" 列
df = pd.read_csv('data.csv', sep='，', usecols=['A', 'B'])

names 参数。这个参数接受一个列表，列表中的元素即为你想要设定的列名。

import pandas as pd

# 读取CSV文件，自定义列名
column_names = ['Name', 'Age', 'City']
df = pd.read_csv('data.csv', sep='，', names=column_names)

在这个例子中，CSV 文件中没有列名，而 column_names 列表指定了三个列的名称为 ‘Name’、‘Age’ 和
‘City’。read_csv() 函数会使用这些列名来解释数据。
需要确保 names 列表的长度与实际列数一致，否则可能会导致解析错误。

2. Excel文件：

   import pandas as pd
   df = pd.read_excel('file.xlsx', sheet_name='Sheet1')
   

3. SQL数据库：

   import pandas as pd
   import sqlite3
   conn = sqlite3.connect('database.db')
   query = 'SELECT * FROM table_name'
   df = pd.read_sql(query, conn)
   

\

3.7.2 文件存储：

1. CSV文件：

   import pandas as pd
   df.to_csv('output.csv', index=False)
   

Df.to_csv(path_or_buf=None, sep=',', columns=None, header=True, index=True, index_label=None, mode='w', encoding=None)

# 保存'x1'列的数据
data[:10].to_csv("test.csv", columns=["x1"])

2. Excel文件：

   import pandas as pd
   df.to_excel('output.xlsx', sheet_name='Sheet1', index=False)
   

3. SQL数据库：

   import pandas as pd
   import sqlite3
   conn = sqlite3.connect('database.db')
   df.to_sql('table_name', conn, index=False, if_exists='replace')
   

以上代码中，df 是一个 Pandas 数据框（DataFrame），你需要替换文件名、数据库连接信息、表名等参数以符合你的实际情况。另外，index 参数用于指定是否保存数据框的索引列。

3.8 数据处理

3.8.1 缺失值处理

1. 判断数据中是否存在NaN：

   • 使用 pd.isnull(df) 可以判断数据中的NaN值。
   • 使用 pd.notnull(df) 可以判断数据中非NaN值。

2. 删除含有缺失值的样本：

   • 使用 df.dropna(inplace=False) 可以删除含有NaN值的样本。注意，这不会修改原始数据，需要接受返回值。

3. 替换/插补：

   • 使用 df.fillna(value, inplace=False) 可以将NaN值替换为指定的值。
     • value 参数指定要替换成的值。
     • inplace=True 会修改原始数据，而 inplace=False 不会修改原始数据，而是生成一个新的对象。

4. 处理不是缺失值nan，有默认标记的：

   • 替换特定标记，例如将 “?” 替换为 NaN，可以使用 df.replace(to_replace="?", value=np.nan)。

代码

import pandas as pd
import numpy as np

# 创建一个简单的示例数据集
data = {'Name': ['John', 'Jane', 'Bob', np.nan],
        'Age': [28, np.nan, 35, 42],
        'Salary': [50000, 60000, np.nan, 75000]}
df = pd.DataFrame(data)

# 显示原始数据集
print("原始数据集:")
print(df)

# 检查数据中是否存在NaN
any_null_using_isnull = np.any(pd.isnull(df).head())
any_not_null_using_notnull = pd.notnull(df).any()

print("\n使用 pd.isnull 检查是否存在NaN:")
print(any_null_using_isnull)

print("\n使用 pd.notnull 检查是否存在非NaN:")
print(any_not_null_using_notnull)

# 删除含有缺失值的样本
data_without_nulls = df.dropna()

print("\n删除含有缺失值的样本:")
print(data_without_nulls)

# 再次检查是否存在NaN
print("\n再次使用 pd.notnull 检查是否存在NaN:")
print(pd.notnull(data_without_nulls).any())

print("\n最终")
print(pd.notnull(data_without_nulls))

结果

3.8.2 数据离散化

将连续型数据转换为离散的形式
常用的方法之一是使用One-Hot编码（独热编码）或创建哑变量。
这两种方法都是将类别型数据转换为二进制形式

GPT

离散化可以将数据划分为不同的类别，从而降低了模型的复杂度。

捕捉到这些非线性关系，提高模型的表达能力。

import pandas as pd
import numpy as np

# 创建一个数据集
data = pd.DataFrame({'Value': np.random.randn(100)})

# 自动分组 - 使用Quantile-based方法
data['Quantile_Groups'] = pd.qcut(data['Value'], q=4)  # 将数据分成4个分位数组

# 自定义分组
custom_bins = [-3, -1, 0, 1, 3]  # 自定义分组边界
data['Custom_Groups'] = pd.cut(data['Value'], bins=custom_bins)

# 将分组结果转换为one-hot编码
quantile_dummies = pd.get_dummies(data['Quantile_Groups'], prefix='Quantile')
custom_dummies = pd.get_dummies(data['Custom_Groups'], prefix='Custom')

# 打印结果
print("原始数据集：")
print(data[['Value']])
print("\n自动分组后：")
print(data[['Value', 'Quantile_Groups']])
print("\n自定义分组后：")
print(data[['Value', 'Custom_Groups']])
print("\nQuantile编码：")
print(quantile_dummies)
print("\nCustom编码：")
print(custom_dummies)

我们首先生成一个包含随机值的数据集。然后，使用Quantile-based方法和自定义分组方法进行离散化。最后，将离散化的结果转换为one-hot编码，生成虚拟变量。

3.8.3 合并操作

在数据处理中，合并操作是常见的操作之一，用于将不同数据集的信息整合在一起。

使用 NumPy 进行数组合并：

1. np.concatenate((a, b), axis=)： 在指定轴上拼接数组a和数组b。

2. 水平拼接：

   np.hstack((a, b))
   

3. 竖直拼接：

   np.vstack((a, b))
   

使用 Pandas 进行 DataFrame 合并：

1. 按方向拼接：

   pd.concat([data1, data2], axis=1)
   

   这将按列方向拼接两个DataFrame。

2. 按索引拼接：

   pd.merge(left, right, how="inner", on=["索引"])
   

   使用 pd.merge 实现按指定索引合并，其中：

   • left 和 right 是要合并的两个DataFrame；
   • how 参数指定合并方式，常见的有 “inner”、“outer”、“left”、“right”；
   • on 参数指定用于合并的索引列。

以下代码演示了如何使用 NumPy 和 Pandas 进行合并操作：

import numpy as np
import pandas as pd

# NumPy 数组合并
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

# 按轴合并
result_np = np.concatenate((a, b), axis=0)

# 水平拼接
result_hstack = np.hstack((a, b.T))

# 竖直拼接
result_vstack = np.vstack((a, b))

# Pandas DataFrame 合并
data1 = pd.DataFrame({'ID': [1, 2], 'Name': ['Alice', 'Bob']})
data2 = pd.DataFrame({'ID': [2, 3], 'Age': [25, 30]})

# 按方向拼接
result_concat = pd.concat([data1, data2], axis=1)

# 按索引拼接
result_merge = pd.merge(data1, data2, how="inner", on="ID")

# 打印结果
print("NumPy 数组合并结果：")
print(result_np)

print("\nPandas DataFrame 合并结果（按方向拼接）：")
print(result_concat)

print("\nPandas DataFrame 合并结果（按索引拼接）：")
print(result_merge)

3.9 注意事项GPT提供

在使用 Pandas 进行数据处理时，有一些注意事项和最佳实践，以确保正确、高效地进行操作。

1. 处理缺失值：

   • 注意使用适当的方法处理缺失值，可以选择删除包含缺失值的行或列，或者使用填充方法。

2. 索引和标签：

   • 注意 DataFrame 的索引和列标签，确保它们清晰、有意义，便于后续的数据操作和分析。

3. 避免直接修改原始数据：

   • 避免直接修改原始数据，尤其是在进行数据清洗和处理时，最好创建新的 DataFrame 或使用 inplace 参数。

4. 数据类型转换：

   • 注意数据类型的正确性，有时需要将列的数据类型转换为适当的类型，以便进行有效的计算和分析。

5. 避免循环操作：

   • 尽量避免使用循环来操作 DataFrame，因为这可能会导致性能问题。尽量使用 Pandas 内置的向量化操作和函数。

6. 合理使用内存：

   • 在处理大型数据集时，要注意内存的使用情况，可以选择只加载所需的列或使用适当的数据类型以减少内存占用。

7. 异常值处理：

   • 谨慎处理异常值，确保不会因为极端值而影响整个分析结果。可以选择删除、替换或进行其他处理。

8. 时间序列：

   • 在处理时间序列数据时，确保正确处理日期和时间，并使用 Pandas 提供的时间序列功能。

9. 性能优化：

   • 了解 Pandas 的性能优化技巧，例如使用向量化操作、使用 apply 方法时谨慎选择函数等，以提高代码的执行效率。

10. 文档和社区：

    • 及时查阅 Pandas 文档和参与社区讨论，因为 Pandas 在不同版本中可能有一些变化，而社区可以提供丰富的经验和解决方案。

11. 版本兼容性：

    • 注意 Pandas 的版本兼容性，特别是在从旧版本升级到新版本时，确保代码仍然能够正确运行。

这些注意事项可以帮助确保使用 Pandas 进行数据处理时的准确性、效率和可维护性。