Python 数据分析：Numpy、Pandas、Matplotlib

# 原生Python列表 vs NumPy数组性能对比
import time
import numpy as np

py_list = list(range(1000000))
np_arr = np.arange(1000000)

# 计算平方和
start = time.time()
sum([x**2 for x in py_list])
print(f"Python列表耗时: {time.time()-start:.4f}s")

start = time.time()
np.sum(np_arr**2)
print(f"NumPy数组耗时: {time.time()-start:.4f}s")

Python列表耗时: 0.1256s  
NumPy数组耗时: 0.0023s

# 不同的数据类型会被强制转换成相同的数据类型
arr = np.array([1, 'hello'])  # 数字和字符串 → 字符串
print(arr)  # ['1' 'hello']

arr = np.array([1, 2.5])  # 整数和浮点数 → 浮点数
print(arr)  # [1.  2.5]

import numpy as np

# 创建一个3x2的二维数组
arr = np.array([[1, 2], [3, 4], [5, 6]])

print("形状 shape:", arr.shape)    # 输出 (3, 2)
print("维度 ndim:", arr.ndim)     # 输出 2
print("总元素 size:", arr.size)   # 输出 6
print("元素类型 dtype:", arr.dtype)  # 输出 int64

import numpy as np

# 从列表创建一维数组
arr1 = np.array([1, 2, 3])
print(arr1)  # 输出: [1 2 3]

# 从嵌套列表创建二维数组
arr2 = np.array([[1, 2], [3, 4]])
print(arr2)
# 输出:
# [[1 2]
#  [3 4]]

# 指定数据类型
arr3 = np.array([1, 2.5], dtype=np.float32)
print(arr3.dtype)  # 输出: float32

import numpy as np
np.zeros(shape, dtype=float)  # 全0  返回给定形状和类型的新数组，用0填充。
np.ones(shape, dtype=float)   # 全1  返回给定形状和类型的新数组，用1填充。

import numpy as np
# 创建 2x3 全0浮点数组
zeros_arr = np.zeros((2, 3))
print(zeros_arr)
# 输出:
# [[0. 0. 0.]
#  [0. 0. 0.]]

# 创建 3x2 全1整数数组
ones_arr = np.ones((3, 2), dtype=int)
print(ones_arr)
# 输出:
# [[1 1]
#  [1 1]
#  [1 1]]

import numpy as np
empty_arr = np.empty((2, 2))
print(empty_arr)  # 输出可能为随机值（如 [[1e-323, 0. ], [0., 0. ]]）

import numpy as np

full_arr = np.full((2, 3), 5)
print(full_arr)
# 输出:
# [[5 5 5]
#  [5 5 5]]

import numpy as np
arr1 = np.array([1, 2, 3])
arr3 = np.array([1, 2.5], dtype=np.float32)

arr2 = np.ones_like(arr1)  # 创建和arr1形状相同的全1数组
arr4 = np.empty_like(arr3)  # 创建和arr3形状相同的未初始化数组
arr2 = np.full_like(arr1, 5)

import numpy as np

arr = np.arange(0, 10, 2)  # 0 ≤ 值 <10，步长2
print(arr)  # 输出: [0 2 4 6 8]

arr = np.linspace(0, 1, 5)  # 0到1之间生成5个等间隔值
print(arr)  # 输出: [0.   0.25 0.5  0.75 1.  ]

arr = np.logspace(0, 2, 3)  # 10^0, 10^1, 10^2
print(arr)  # 输出: [  1.  10. 100.]

- 形状（shape）：这个矩阵有 2 行 3 列，记作 2×3 矩阵。
- 元素（entry）：矩阵中的每个数字称为元素，如 A<sub>1,2</sub>=2（第 1 行第 2 列）。

    * _A_ 是系数矩阵，
    * **x** 是未知数列向量，
    * **b** 是常数项列向量。
2. **表示线性变换**，矩阵可以描述空间中的变换，比如旋转、缩放、投影。

3. **数据表示**（如机器学习）。在机器学习中，数据集通常用矩阵表示：
    * 每一行代表一个样本（如一张图片），
    * 每一列代表一个特征（如像素值）。

2. 矩阵数乘。矩阵的每个元素乘以一个标量（数）：

3. 矩阵乘法。行 × 列 的点积运算（矩阵乘法 不是 对应元素相乘）：

4. 转置（Transpose）。行列互换：

np.eye(N)  # NxN 单位矩阵
np.identity(N)

eye_arr = np.eye(3)
print(eye_arr)
# 输出:
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

np.diag([a, b, c])  # 对角线为 a, b, c，其余为0

diag_arr = np.diag([1, 2, 3])
print(diag_arr)
# 输出:
# [[1 0 0]
#  [0 2 0]
#  [0 0 3]]

rand_arr = np.random.rand(2, 2)  # [0,1) 均匀分布
# 输出示例: [[0.43, 0.89], [0.21, 0.57]]

randn_arr = np.random.randn(2, 2)  # 均值为0，方差为1
# 输出示例: [[-0.5, 1.2], [0.3, -1.8]]

int_arr = np.random.randint(1, 10, (2, 2))  # [1,10) 的整数
# 输出示例: [[3, 7], [5, 2]]

arr3 = np.random.uniform(3, 6, (2, 3))
# [[5.69275495 3.84857937 3.2899215 ]
#  [5.32035519 3.7460973  3.33859905]]

import numpy as np

# 设置随机种子
np.random.seed(42)  # 参数可以是任意整数

# 生成随机数
print(np.random.rand(3))  # 输出固定结果

1. **种子的一致性**：
    * 相同种子生成的随机数序列完全一致。
    * 不同种子（如 np.random.seed(0) 和 np.random.seed(1)）会产生不同序列。
2. **作用范围**：
    * 种子对后续所有基于 NumPy 的随机函数生效（如 np.random.rand(), np.random.normal(), np.random.shuffle() 等）。

data = np.loadtxt('data.txt')  # 读取文本文件

data = np.genfromtxt('data.csv', delimiter=',')  # 支持复杂格式

arr1 = np.array([1, 2, 3], dtype=np.float64)# [1. 2. 3.]
arr2 = np.array([0.2, 2.5, 4.8], dtype="i8")# [0 2 4]

arr1 = np.array([1, 2, 3], dtype=np.float64)# [1. 2. 3.]
arr2 = arr1.astype(np.int64)# [1 2 3]

# 显式指定数据类型
arr = np.array([1, 2, 3], dtype=np.float32)

# 类型转换
int_arr = arr.astype(np.int32)

# 内存优化示例
large_arr = np.ones(1000000, dtype=np.float64)  # 占用8MB
optimized = large_arr.astype(np.float32)        # 优化为4MB

arr = np.arange(1, 10).reshape(3,3)
print(arr[1, 2])       # 第2行第3列 → 6
print(arr[:, 1])       # 所有行的第2列 → [2 5 8]
print(arr[::2, ::2])   # 隔行隔列取样 → [[1,3],[7,9]]

# 布尔索引实战
data = np.random.randn(100)
print(data[(data > 0.5) & (data < 1.0)]) # 条件筛选

import numpy as np
arr = np.arange(10)
print(arr)# [0 1 2 3 4 5 6 7 8 9
#获取索引为2的数据
print(arr[2])# 2
# 从索引 2开始到索引9(不包含)停止，间隔为2
print(arr[slice(2,9,2)])# [2 4 6 8]
# 从索引2开始到索引9(不包含)停止，间隔为2
print(arr[2:9:2])# [2 4 6 8]
# 从索引2开始到最后(不包含)，默认间隔为1
print(arr[2:])# [2 3 4 5 6 7 8 9]
# 从索引2开始到索引9(不包含)结束，默认间隔为1
print(arr[2:9])# [2 3 4 5 6 7 8]

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
print(arr1 + arr2)
print(arr1 - arr2)
print(arr1 * arr2)
print(arr1 / arr2)

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr1 + 100)
print(arr1 - 100)
print(arr1 * 100)
print(arr1 / 100)

import numpy as np
# 一维数组
arr1 = np.array([1, 2, 3])  # 形状为 (3,)
# 二维数组
arr2 = np.array([[4], [5], [6]])  # 形状为 (3, 1)
# 对 arr1 应用规则 1，在其形状最左边补 1，变为 (1, 3)  [[1,2,3]]
# 此时 arr1 形状 (1, 3) 和 arr2 形状 (3, 1) 满足广播条件
result = arr1 + arr2
print("规则 1 示例结果：\n", result)

import numpy as np
# 二维数组
arr3 = np.array([[1, 2, 3]])  # 形状为 (1, 3)
# 二维数组
arr4 = np.array([[4], [5], [6]])  # 形状为 (3, 1)
# arr3 沿着第0个维度扩展,将原有的一行数据复制成3行,为 (3, 3)=>[[1,2,3], [1,2,3], [1,2,3]]
# arr4 沿着第1个维度扩展, (3, 3)=>[[4,4,4], [5,5,5], [6,6,6]]
result = arr3 + arr4
print("规则 2 示例结果：\n", result)

# 规则3：如果俩个数组的形状在任何一个维度上都不匹配，并且没有任何一个维度大小等于1，那么会引发异常。import numpy as np
# 一维数组
arr5 = np.array([1, 2, 3])  # 形状为 (3,)
# 一维数组
arr6 = np.array([4, 5])  # 形状为 (2,)
try:
    result = arr5 + arr6    
    print(result)
except ValueError as e:
    print(f"规则 3 示例错误信息：{e}")

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # 矢量化加法 → [5, 7, 9]

1. 两个 shape 已经同维度（都是 2 维），不用补维
2. 两个向量逐维比较：
    * 第 1 维：`5` 和 `1` → 有 `1`
    * 第 2 维：`1` 和 `7` → 有 `1`
3. 每一维都满足规则

- `(5, 1)`：每一行只有 1 个数 → 横向复制成 7 列
- `(1, 7)`：只有 1 行 → 纵向复制成 5 行

1. `(3,)` 右对齐补 1：

(2, 2)
(1, 3)

2. 从右往左比：第 2 维：`2` 和 `3` 不相等，且都不是 1

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # 直接逐元素相加 → [5, 7, 9]

a = np.array([[1], [2], [3]])  # shape (3, 1)
b = np.array([10, 20, 30])     # shape (3,)
c = a + b
# 广播步骤：
# 1. a 扩展为 [[1, 1, 1], [2, 2, 2], [3, 3, 3]]（虚拟扩展，不实际复制）
# 2. b 扩展为 [[10, 20, 30], [10, 20, 30], [10, 20, 30]]
# 结果：
# [[11, 21, 31],
#  [12, 22, 32],
#  [13, 23, 33]]

a = np.array([1, 2, 3])
b = np.array([10, 20])
a + b  # 报错：shapes (3,) and (2,) cannot be broadcast

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[6, 5, 4], [3, 2, 1]])
print(arr1 * arr2)
print(np.multiply(arr1, arr2))
# [[ 6 10 12]
#  [12 10  6]]

# [[ 6 10 12]
#  [12 10  6]]

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[6, 5], [4, 3], [2, 1]])#对于矩阵乘法来说，要求第一个矩阵的列数等于第二个矩阵的行数
print(arr1)
print(arr2)
print(arr1.shape, arr2.shape)
print(np.dot(arr1, arr2))
print(arr1.dot(arr2))
print(arr1 @ arr2)# 一个二维数组跟一个大小合适的一维数组的矩阵点积运算之后将会得到一个一维数组
arr3 = np.array([6, 5, 4])
print(arr3.shape)
print(arr1 @ arr3)

# 运行结果：
# [[1 2 3]
#  [4 5 6]]

# [[6 5]
#  [4 3]
#  [2 1]]

# (2, 3) (3, 2)

# [[20 14]
#  [56 41]]

# [[20 14]
#  [56 41]]

# [[20 14]
#  [56 41]]

# (3,)
# [28 73]

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])

# 逐元素运算
print(A * B)   # [[5,12],[21,32]] 

# 矩阵乘法
print(A @ B)   # [[19,22],[43,50]]

# 广播机制演示
C = np.array([10,20])
print(A + C)   # [[11,22],[13,24]]

arr1 = np.random.randn(2, 3)
print(arr1)
print(np.abs(arr1))
print(np.ceil(arr1))
print(np.floor(arr1))
print(np.rint(arr1))
print(np.isnan(arr1))
print(np.multiply(arr1, 2))
print(np.divide(arr1, arr1))

arr1 = np.random.randint(1, 5, (2, 3))
print(arr1)
print(np.mean(arr1))
print(np.sum(arr1))
print(np.max(arr1))
print(np.min(arr1))
print(np.std(arr1))
print(np.var(arr1))
print(np.argmax(arr1))
print(np.argmin(arr1))
print(np.cumsum(arr1))
print(np.cumprod(arr1))
print(np.cumprod(arr1, axis=1))

import numpy as np
arr1 = np.random.randint(0, 10, (3, 3))
print(arr1)
arr1.sort()
print(arr1)
arr1.sort(axis=0)
print(arr1)
arr1 = np.random.randint(0, 10, (3, 3))
print(arr1)
print(np.sort(arr1))

import numpy as np
arr1 = np.random.randint(0, 5, (3, 3))
print(arr1)
print(np.unique(arr1))
# 运行结果：
# [[0 3 2]
#  [2 2 1]
#  [1 2 3]]
# [0 1 2 3]

import pandas as pd
s = pd.Series([10, 20, 30], index=["a", "b", "c"])
print(s)
# a    10
# b    20
# c    30
# dtype: int64

import pandas as pd
s = pd.Series([4, 7, -5, 3])print(s)
# 0    4
# 1    7
# 2   -5
# 3    3
# dtype: int64

import pandas as pd

s = pd.Series([4, 7, -5, 3], index=["a", "b", "c", "d"])
print(s)
# a    4
# b    7
# c   -5
# d    3
# dtype: int64

import pandas as pd

s = pd.Series([4, 7, -5, 3], index=["a", "b", "c", "d"],name="hello_python")
print(s)
# a    4
# b    7
# c   -5
# d    3
# Name: hello_python, dtype: int6

import pandas as pd
s = pd.Series([4, 7, -5, 3], index=["a", "b", "c", "d"],name="hello_python")

df = s.to_frame()  # 转换为 DataFrame，列名就是 "hello_python"
print(df)
#     hello_python
# a             4
# b             7
# c            -5
# d             3

import pandas as pd

dic = {"a": 4, "b": 7, "c": -5, "d": 3}
s = pd.Series(dic)
print(s)
# a    4
# b    7
# c   -5
# d    3
# dtype: int64
s1 = pd.Series(dic,index=["a","c"],name="aacc")
print(s1)
# a    4
# c   -5
# Name: aacc, dtype: int64

import pandas as pd

s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
# 位置索引
print(s.iloc[0])  # 10
# 标签访问
print(s["a"])  
# 标签索引
print(s.loc['b'])  # 20
# 布尔索引
print(s[s > 25])  # c:30, d:40
# 花式索引
print(s[['a', 'c']])  # a:10, c:30

#使用布尔索引从Series中筛选满足某些条件的值
print("mean:" + str(s.mean())) # 25.0
bools = s > s.mean()  
# 将大于平均值的元素标记为 True
print(bools)
# a    False
# b    False
# c     True
# d     True
# dtype: bool
print(s[bools])# b    3.5
# c    6.8
# dtype: float64# 使用where过滤
print(s.where(s > 20, -1))  # 小于等于20的值替换为-1

import pandas as pd
arrs = pd.Series([11,22,33,44,55],name="atguigu",index=["a","b","c","d","e"])
# print(arrs)
# index Series的索引对象
print(arrs.index)
for i in arrs.index:
    print(i)
    print(arrs.values) # values Series的值
print(arrs.ndim)  # ndim  Series的维度
print(arrs.shape)  # shape Series的形状
print(arrs.size) # size  Series的元素个数
# dtype或dtypes  Series的元素类型
print(arrs.dtype)
print(arrs.dtypes)
# name  Series的名称
print(arrs.name)
# loc[] 显式索引，按标签索引或切片
print(arrs.loc["c"])
print(arrs.loc["c":"d"])
# iloc[]    隐式索引，按位置索引或切片
print(arrs.iloc[0])
print(arrs.iloc[0:3])
# at[]  使用标签访问单个元素
print(arrs.at["a"])
# iat[] 使用位置访问单个元素
print(arrs.iat[3])

import pandas as pd

s1 = pd.Series([1, 2, 3, 4])
s2 = pd.Series([10, 20, 30, 40])
# 基本运算
print(s1 + s2)  # 对应位置相加
print(s1 * 2)   # 标量乘法

import pandas as pd
import numpy as np
arrs = pd.Series([11,22,np.nan,None,44,22],index=['a','b','c','d','e','f'])
# head()    查看前n行数据，默认5行
print(arrs.head())
# tail()    查看后n行数据，默认5行
print(arrs.tail(3))
# describe()    常见统计信息
print(arrs.describe())
# count()   非缺失值元素的个数
print(arrs.count())
# keys()    返回Series的索引对象
print(arrs.index)
print(arrs.keys())
# isin()    判断数组中的每一个元素是否包含在参数集合中
print(arrs.isin([11]))
# isna()    元素是否为缺失值
print(arrs.isna())

#统计# sum() 求和，会忽略 Series 中的缺失值
print(arrs.sum())
# mean()    平均值
print(arrs.mean())
# min() 最小值
print(arrs.min())
# max() 最大值
print(arrs.max())
# var() 方差 每个元素与平均值的差 的平方 的和
print(arrs.var())
# std() 标准差 方差的平方根
print(arrs.std())
# print(arrs.var())
# median()  中位数
# 若数据集的元素个数为奇数，中位数就是排序后位于中间位置的数值。
# 若数据集的元素个数为偶数，中位数则是排序后中间两个数的平均值。
# 去除缺失值之后，arrs 就变成了 [11, 22, 44, 22]。
# 对 [11, 22, 44, 22] 进行排序，得到 [11, 22, 22, 44]
print(arrs.median())
# mode()    众数
print(arrs.mode())
# quantile()    指定位置的分位数，如quantile(0.5)
# 分位数：分位数是把一组数据按照从小到大的顺序排列后，分割成若干等份的数值点。
# 0.25 分位数就是将数据从小到大排序后，位于 25% 位置处的数值。
# 插值方法：当计算分位数时，若位置不是整数，就需要借助插值方法来确定分位数值。# "midpoint" 插值方法是指当分位数位置处于两个数据点之间时，取这两个数据点的
# 平均值作为分位数值。
# 对于有 n个数据点的有序数据集，q分位数的位置 i可以通过公式 i=(n−1)q来计
# 算。这里 n=4，q=0.25，则 i=(4−1)×0.25=0.75。这意味着 0.25 分位数处于第一个# 数据点（值为 11）和第二个数据点（值为 22）之间。使用 "midpoint" 插值方法，
# 分位数值就是这两个数据点的平均值，即 (11+22)÷2=16.5
print(arrs.quantile(0.25, interpolation="midpoint"))

print(len(arrs))
# drop_duplicates() 去重  这里可以看出，底层None也作为NaN处理
print(arrs.drop_duplicates())
# unique()  去重后的数组
print(arrs.unique())
# nunique() 去重后非缺失值元素元素个数
print(arrs.nunique())
# sample()  随机采样
print(arrs.sample())
# value_counts()    每个元素的个数
print(arrs.value_counts())
# sort_index()  按索引排序
print(arrs.sort_index())
# sort_values() 按值排序
print(arrs.sort_values())
# replace() 用指定值代替原有值
print(arrs.replace(22,"haha"))
# to_frame()    将Series转换为DataFrame
print(arrs.to_frame())
# equals()  判断两个Series是否相同
arr1 = pd.Series([1,2,3])
arr2 = pd.Series([1,2,3])
print(arr1.equals(arr2))
# corr()    计算与另一个Series的相关系数
# arr1.corr(arr2)：由于 arr1 和 arr2 的值完全相同，它们之间是完全正相关的，
#因此相关系数为 1。
# arr1.corr(arr3)：arr1 的值是递增的，而 arr3 的值是递减的，它们之间是完全
# 负相关的，所以相关系数为 -1。
# arr1.corr(arr4)：arr1 和 arr4 的值都是递增的，且变化趋势一致，它们之间是
# 完全正相关的，相关系数为 1。
# arr5.corr(arr6)：arr5 和 arr6 的值之间没有明显的线性关系，它们的相关系数
# 为 0。
arr3 = pd.Series([3,2,1])
arr4 = pd.Series([6,7,8])
arr5 = pd.Series([1, -1, 1, -1])
arr6 = pd.Series([1, 1, -1, -1])
print(arr1.corr(arr2))
print(arr1.corr(arr3))
print(arr1.corr(arr4))
print(arr5.corr(arr6))
# cov() 计算与另一个Series的协方差
# 协方差用于衡量两个变量的总体误差，其值的正负表示两个变量的变化方向关系：
# 正值表示同向变化，负值表示反向变化。
print(arr1.cov(arr3))

import pandas as pd
import numpy as np

# 生成随机成绩
np.random.seed(42)
scores = pd.Series(np.random.randint(50, 101, 10), 
                  index=['学生'+str(i) for i in range(1, 11)])

# 计算统计量
mean_score = scores.mean()
max_score = scores.max()
min_score = scores.min()
above_avg = scores[scores > mean_score].count()

print(f"平均分: {mean_score:.1f}")
print(f"最高分: {max_score}")
print(f"最低分: {min_score}")
print(f"高于平均分的学生人数: {above_avg}")

import pandas as pd
import numpy as np
temperatures = pd.Series([28, 31, 29, 32, 30, 27, 33], 
                         index=['周一', '周二', '周三', '周四', '周五', '周六', '周日'])

# 1. 找出温度超过30度的天数
hot_days = temperatures[temperatures > 30].count()

# 2. 计算平均温度
avg_temp = temperatures.mean()

# 3. 将温度从高到低排序
sorted_temp = temperatures.sort_values(ascending=False)

# 4. 找出温度变化最大的两天
temp_diff = temperatures.diff().abs()
max_diff_days = temp_diff.nlargest(2).index.tolist()

print(f"超过30度的天数: {hot_days}")
print(f"平均温度: {avg_temp:.1f}")
print("温度排序:\n", sorted_temp)
print(f"温度变化最大的两天: {max_diff_days}")

import pandas as pd
import numpy as np
prices = pd.Series([102.3, 103.5, 105.1, 104.8, 106.2, 107.0, 106.5, 108.1, 109.3, 110.2],
                  index=pd.date_range('2023-01-01', periods=10))

# 1. 计算每日收益率
returns = prices.pct_change()

# 2. 找出收益率最高和最低的日期
max_return_date = returns.idxmax()
min_return_date = returns.idxmin()

# 3. 计算波动率
volatility = returns.std()

print("每日收益率:\n", returns)
print(f"收益率最高的日期: {max_return_date}")
print(f"收益率最低的日期: {min_return_date}")
print(f"波动率: {volatility:.4f}")

import pandas as pd
import numpy as np
sales = pd.Series([120, 135, 145, 160, 155, 170, 180, 175, 190, 200, 210, 220],
                 index=pd.date_range('2022-01-01', periods=12, freq='M'))

# 1. 计算季度平均销量
quarterly_avg = sales.resample('Q').mean()

# 2. 找出销量最高的月份
max_sales_month = sales.idxmax()

# 3. 计算月环比增长率
mom_growth = sales.pct_change()

# 4. 找出连续增长超过2个月的月份
growth_mask = mom_growth > 0
consecutive_growth = growth_mask.rolling(3).sum() >= 2
growth_months = sales[consecutive_growth].index

print("季度平均销量:\n", quarterly_avg)
print(f"销量最高的月份: {max_sales_month}")
print("月环比增长率:\n", mom_growth)
print("连续增长超过2个月的月份:", growth_months.tolist())

import pandas as pd
import numpy as np
city_a = pd.Series([120, 135, 140, 130, 145],
                  index=pd.date_range('2023-01-01', periods=5))
city_b = pd.Series([110, 125, 150, 140, 130],
                  index=pd.date_range('2023-01-01', periods=5))

# 1. 计算两个城市的总日销量
total_sales = city_a + city_b

# 2. 找出哪个城市的销量更高
city_a_total = city_a.sum()
city_b_total = city_b.sum()
higher_sales_city = 'A' if city_a_total > city_b_total else 'B'

# 3. 计算两个城市销量的相关系数
correlation = city_a.corr(city_b)

print("总日销量:\n", total_sales)
print(f"总销量更高的城市: {higher_sales_city}")
print(f"两个城市销量的相关系数: {correlation:.2f}")

df = pd.DataFrame({
    "name": ["Alice", "Bob"],
    "score": [90, 80]
})

# 
import pandas as pd
import numpy as np
np.random.seed(42)
s1 = pd.Series(np.random.randint(0,10,6))
np.random.seed(41)
s2 = pd.Series(np.random.randint(0,20,6))
df = pd.DataFrame({"s1":s1,"s2":s2})

import pandas as pd
df = pd.DataFrame({"name": ["Alice", "Bob"],"score": [90, 80]})
print(df)
df = pd.DataFrame({"id": [101, 102, 103], "name": ["张三", "李四", "王五"], "age": [20, 30, 40]})
print(df)
#     id name  age
# 0  101   张三   20
# 1  102   李四   30
# 2  103   王五   40

df = pd.DataFrame(
    data={"age": [20, 30, 40], 
    "name": ["张三", "李四", "王五"]}, 
    columns=["name", "age"], index=[101, 102, 103]
)
print(df)
#     name  age
# 101   张三   20
# 102   李四   30
# 103   王五   40

df[(df['col1'] > 3) & (df['col2'] == 'A')]

# 访问数据
print(df['name'])  #访问某列数据
print(df.score)
 # df["col"] / df.col
df["name"]       # 返回 Series
df.name      
df[["name"]]     # 返回 DataFrame

df[["date", "temp_max", "temp_min"]]  # 获取多列数据print(df[['name','score']]) # 访问多列数据

df.loc[1]  # 获取行标签为1的数据
df.loc[[1, 10, 100]]  # 获取行标签分别为1、10、100的数据

df.iloc[0]  # 获取行位置为0的数据
df.iloc[-1]  # 获取行位置为最后一位的数据

df.loc[101, "name"]    # 标签访问
df.iloc[0, 1]          # 位置访问df.loc[1, "precipitation"]  # 获取行标签为1，列标签为precipitation的数据
df.loc[:, "precipitation"]  # 获取所有行，列标签为precipitation的数据
df.iloc[:, [3, 5, -1]]  # 获取所有行，列位置为3，5，最后一位的数据
df.iloc[:10, 2:6]  # 获取前10行，列位置为2、3、4、5的数据
df.loc[:10, ["date", "precipitation", "temp_max", "temp_min"]]  # 通过行列标签获取数据

print(df.head())print(df.tail(10))

# 条件筛选
df['score']>70
print(df[df.score>70])
print(df[(df['score']>70) & (df['age']<20)])# 随机抽样
df.sample(2)

import pandas as pd
df = pd.DataFrame(data={"id": [101, 102, 103], "name": ["张三", "李四", "王五"], "age": [20, 30, 40]},index=["aa", "bb", "cc"])# index DataFrame的行索引
print(df.index)
# columns   DataFrame的列标签
print(df.columns
     )# values    DataFrame的值
print(df.values)
# ndim  DataFrame的维度
print(df.ndim)
# shape DataFrame的形状
print(df.shape)
# size  DataFrame的元素个数
print(df.size)
# dtypes    DataFrame的元素类型
print(df.dtypes)
# T 行列转置
print(df.T)
# loc[] 显式索引，按行列标签索引或切片 逗号前是行切片规则，后是列切片规则
print(df.loc["aa":"cc"])
print(df.loc[:,["id","name"]])
# iloc[]    隐式索引，按行列位置索引或切片
print(df.iloc[0:1])
print(df.iloc[0:3,2])
print("----------")
# at[]  使用行列标签访问单个元素
print(df.at["aa","name"])
# iat[] 使用行列位置访问单个元素
print(df.iat[0,1])

import pandas as pd
from typing import Any, Optional

def create_dataframe() -> pd.DataFrame:
    """
    创建一个包含 id、name 和 age 列的 DataFrame。

    Returns:
        pd.DataFrame: 包含示例数据的 DataFrame。
    """
    data = {
        "id": [101, 102, 103, 104, 105, 106, 101],
        "name": ["张三", "李四", "王五", "赵六", "冯七", "周八", "张三"],
        "age": [10, 20, 30, 40, None, 60, 10]
    }
    index = ["aa", "bb", "cc", "dd", "ee", "ff", "aa"]
    return pd.DataFrame(data, index=index)

def print_statistics(df: pd.DataFrame) -> None:
    """
    打印 DataFrame 的基本统计信息。

    Args:
        df (pd.DataFrame): 输入的 DataFrame。
    """
    print("=== 前几行数据 ===")
    print(df.head())

    print("\n=== 后几行数据 ===")
    print(df.tail())

    print("\n=== 检查元素是否存在于指定集合中 ===")
    print(df.isin([103, 106]))

    print("\n=== 检查缺失值 ===")
    print(df.isna())

    print("\n=== 年龄列的总和 ===")
    print(df["age"].sum())

    print("\n=== 年龄列的平均值 ===")
    print(df["age"].mean())

    print("\n=== 年龄列的最小值 ===")
    print(df["age"].min())

    print("\n=== 年龄列的最大值 ===")
    print(df["age"].max())

    print("\n=== 年龄列的方差 ===")
    print(df["age"].var())

    print("\n=== 年龄列的标准差 ===")
    print(df["age"].std())

    print("\n=== 年龄列的中位数 ===")
    print(df["age"].median())

    print("\n=== 年龄列的众数 ===")
    print(df["age"].mode())

    print("\n=== 年龄列的中位数（分位数 0.5） ===")
    print(df["age"].quantile(0.5))

    print("\n=== 数据的基本统计信息 ===")
    print(df.describe())

    print("\n=== 数据基本信息 ===")
    print(df.info())

    print("\n=== 每个元素的出现次数 ===")
    print(df.value_counts())

    print("\n=== 非空元素的个数 ===")
    print(df.count())

    print("\n=== 是否有重复行（按 age 列）===\n")
    print(df.duplicated(subset="age"))

    print("\n=== 随机采样一行 ===")
    print(df.sample())

    print("\n=== 替换特定值 ===")
    print(df.replace(20, "haha"))

    print("\n=== 累计最大值（按行）===\n")
    df3 = pd.DataFrame({'A': [2, 5, 3, 7, 4], 'B': [1, 6, 2, 8, 3]})
    print(df3.cummax(axis="columns"))

    print("\n=== 累计最小值 ===")
    print(df3.cummin())

    print("\n=== 累计和 ===")
    print(df3.cumsum())

    print("\n=== 累计积 ===")
    print(df3.cumprod())

    print("\n=== 一阶差分 ===")
    print(df3.diff())

    print("\n=== 按行索引排序 ===")
    print(df.sort_index())

    print("\n=== 按年龄列排序 ===")
    print(df.sort_values(by="age"))

    print("\n=== 年龄最大的两行 ===")
    print(df.nlargest(n=2, columns="age"))

    print("\n=== 年龄最小的一行 ===")
    print(df.nsmallest(n=1, columns="age"))

if __name__ == "__main__":
    dataframe = create_dataframe()
    print_statistics(dataframe)

import pandas as pd

df = pd.DataFrame(data={"age": [20, 30, 40, 10], "name": ["张三", "李四", "王五", "赵六"]},
    columns=["name", "age"],
    index=[101, 104, 103, 102],
)
print(df * 2)
#      name     age
# 101  张三张三   40
# 104  李四李四   60
# 103  王五王五   80
# 102  赵六赵六   20
df1 = pd.DataFrame(
    data={"age": [10, 20, 30, 40], "name": ["张三", "李四", "王五", "赵六"]},
    columns=["name", "age"],
    index=[101, 102, 103, 104],
)
df2 = pd.DataFrame(
    data={"age": [10, 20, 30, 40], "name": ["张三", "李四", "王五", "田七"]},
    columns=["name", "age"],
    index=[102, 103, 104, 105],
)
print(df1 + df2)#      name   age
# 101   NaN   NaN
# 102  李四张三  30.0
# 103  王五李四  50.0
# 104  赵六王五  70.0
# 105   NaN   NaN

import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五', '赵六', '钱七'],
    '数学': [85, 92, 78, 88, 95],
    '英语': [90, 88, 85, 92, 80],
    '物理': [75, 80, 88, 85, 90]
}
df = pd.DataFrame(data)

# 1. 计算总分和平均分
df['总分'] = df[['数学', '英语', '物理']].sum(axis=1)
df['平均分'] = df['总分'] / 3

# 2. 找出数学>90或英语>85的学生
high_scores = df[(df['数学'] > 90) | (df['英语'] > 85)]

# 3. 按总分排序并输出前3名
top3 = df.sort_values('总分', ascending=False).head(3)

print("总分和平均分：\n", df)
print("\n数学>90或英语>85的学生：\n", high_scores)
print("\n总分前3名学生：\n", top3)

import pandas as pd

data = {
    '产品名称': ['A', 'B', 'C', 'D'],
    '单价': [100, 150, 200, 120],
    '销量': [50, 30, 20, 40]
}
df = pd.DataFrame(data)

# 1. 计算总销售额
df['销售额'] = df['单价'] * df['销量']

# 2. 找出销售额最高的产品
max_sales = df[df['销售额'] == df['销售额'].max()]

# 3. 按销售额排序
sorted_df = df.sort_values('销售额', ascending=False)

print("销售额计算：\n", df)
print("\n销售额最高的产品：\n", max_sales)
print("\n按销售额排序：\n", sorted_df)

import pandas as pd

data = {
    '姓名': ['张三', '李四', '王五', '赵六'],
    '出勤天数': [20, 15, 18, 22],
    '工作日总数': [25, 20, 25, 25]
}
df = pd.DataFrame(data)

# 1. 计算出勤率
df['出勤率'] = (df['出勤天数'] / df['工作日总数']).round(2)

# 2. 标记出勤率<80%的员工
df['需关注'] = df['出勤率'] < 0.8

# 3. 按出勤率排序
sorted_df = df.sort_values('出勤率', ascending=False)

print("出勤率统计：\n", df)
print("\n出勤率排序：\n", sorted_df)

import pandas as pd

data = {
    '电影名称': ['电影A', '电影B', '电影C', '电影D'],
    '评分1': [9.0, 8.5, 8.0, 7.5],
    '评分2': [8.5, 9.0, 8.5, 8.0],
    '评分3': [9.5, 8.0, 7.5, 7.0]
}
df = pd.DataFrame(data)

# 1. 计算平均评分
df['平均评分'] = df[['评分1', '评分2', '评分3']].mean(axis=1).round(2)

# 2. 找出评分>8.5的电影
high_rated = df[df['平均评分'] > 8.5]

# 3. 按平均评分排序
sorted_df = df.sort_values('平均评分', ascending=False)

print("平均评分：\n", df)
print("\n评分>8.5的电影：\n", high_rated)
print("\n按评分排序：\n", sorted_df)

import pandas as pd

data = {
    '日期': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'],
    '收盘价': [100, 105, 110, 102]
}
df = pd.DataFrame(data)
df['日期'] = pd.to_datetime(df['日期'])

# 1. 计算涨跌幅
df['涨跌幅'] = df['收盘价'].pct_change().round(4)

# 2. 找出涨幅>5%的日期
high_increase = df[df['涨跌幅'] > 0.05]

# 3. 按日期排序并输出最高涨跌幅日期
sorted_df = df.sort_values('日期')
max_increase_date = df.loc[df['涨跌幅'].idxmax(), '日期']

print("涨跌幅计算：\n", df)
print("\n涨幅>5%的日期：\n", high_increase)
print("\n涨跌幅最高的日期：\n", max_increase_date)

import pandas as pd

data = {
    '用户ID': [101, 102, 103, 104, 105],
    '用户名': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    '商品类别': ['电子产品', '服饰', '电子产品', '家居', '服饰'],
    '商品单价': [1200, 300, 800, 150, 200],
    '购买数量': [1, 3, 2, 5, 4]
}
df = pd.DataFrame(data)

# 1. 计算总消费金额
df['消费金额'] = df['商品单价'] * df['购买数量']

# 2. 找出消费金额最高的用户
max_spend_user = df[df['消费金额'] == df['消费金额'].max()]

# 3. 计算平均消费金额
avg_spend = round(df['消费金额'].mean(), 2)

# 4. 统计电子产品的总购买数量
electronic_total = df[df['商品类别'] == '电子产品']['购买数量'].sum()

print("用户消费分析：\n", df)
print("\n消费金额最高的用户：\n", max_spend_user)
print("\n平均消费金额：", avg_spend)
print("电子产品总购买数量：", electronic_total)

用户消费分析：
    用户ID     用户名  商品类别  商品单价  购买数量  消费金额
0   101    Alice  电子产品   1200       1   1200
1   102      Bob     服饰    300       3    900
2   103  Charlie  电子产品    800       2   1600
3   104    David     家居    150       5    750
4   105      Eve     服饰    200       4    800

消费金额最高的用户：
    用户ID     用户名  商品类别  商品单价  购买数量  消费金额
2   103  Charlie  电子产品    800       2   1600

平均消费金额： 1050.0
电子产品总购买数量： 3

import os
import pandas as pd
os.makedirs("data", exist_ok=True)
df = pd.DataFrame({"age": [20, 30, 40, 10], "name": ["张三", "李四", "王五", "赵六"], "id": [101, 102, 103, 104]})
df.set_index("id", inplace=True)
df.to_csv("data/df.csv")
df.to_csv("data/df.tsv", sep="\t")  # 设置分隔符为 \t
df.to_csv("data/df_noindex.csv", index=False)  # index=False 不保存行索引
df.to_pickle("data/df.pkl")
df.to_excel("data/df.xlsx")
df.to_clipboard()
df_dict = df.to_dict()
df.to_hdf("data/df.h5", key="df")
df.to_html("data/df.html")
df.to_json("data/df.json")
df.to_feather("data/df.feather")

import os
import pandas as pd
df_csv = pd.read_csv("data/df.csv", index_col="id")  # 指定行索引
df_tsv = pd.read_csv("data/df.tsv", sep="\t")  # 指定分隔符
df_pkl = pd.read_pickle("data/df.pkl")
df_excel = pd.read_excel("data/df.xlsx", index_col="id")
df_clipboard = pd.read_clipboard(index_col="id")
df_from_dict = pd.DataFrame(df_dict)
df_hdf = pd.read_hdf("data/df.h5", key="df")
df_html = pd.read_html("data/df.html", index_col=0)[0]
df_json = pd.read_json("data/df.json")
df_feather = pd.read_feather("data/df.feather")
print(df_csv)
print(df_tsv)
print(df_pkl)
print(df_excel)
print(df_clipboard)
print(df_from_dict)
print(df_hdf)
print(df_html)
print(df_json)
print(df_feather)

s = pd.Series([np.nan, None, pd.NA])
print(s)
# 0     NaN
# 1    None
# 2    <NA>
# dtype: object
print(s.isnull())
# 0    True
# 1    True
# 2    True
# dtype: bool

df = pd.read_csv("data/weather_withna.csv")print(df.tail(5))
#             date  precipitation  temp_max  temp_min  wind weather
# 1456  2015-12-27            NaN       NaN       NaN   NaN     NaN
# 1457  2015-12-28            NaN       NaN       NaN   NaN     NaN
# 1458  2015-12-29            NaN       NaN       NaN   NaN     NaN
# 1459  2015-12-30            NaN       NaN       NaN   NaN     NaN
# 1460  2015-12-31           20.6      12.2       5.0   3.8    rain

df = pd.read_csv("data/weather_withna.csv", keep_default_na=False)print(df.tail(5))
#             date precipitation temp_max temp_min wind weather
# 1456  2015-12-27
# 1457  2015-12-28
# 1458  2015-12-29
# 1459  2015-12-30
# 1460  2015-12-31          20.6     12.2      5.0  3.8    rain

df = pd.read_csv("data/weather_withna.csv", na_values=["2015-12-31"])print(df.tail(5))
#             date  precipitation  temp_max  temp_min  wind weather
# 1456  2015-12-27            NaN       NaN       NaN   NaN     NaN
# 1457  2015-12-28            NaN       NaN       NaN   NaN     NaN
# 1458  2015-12-29            NaN       NaN       NaN   NaN     NaN
# 1459  2015-12-30            NaN       NaN       NaN   NaN     NaN
# 1460         NaN           20.6      12.2       5.0   3.8    rain

df = pd.read_csv("data/weather_withna.csv")
print(df.isnull().sum())
# date               0
# precipitation    303
# temp_max         303
# temp_min         303
# wind             303
# weather          303
# dtype: int64

s = pd.Series([1, pd.NA, None])
print(s)
# 0       1
# 1    <NA>
# 2    None
# dtype: object
print(s.dropna())
# 0    1
# dtype: object

df = pd.DataFrame([[1, pd.NA, 2], [2, 3, 5], [pd.NA, 4, 6]])
print(df)
#       0     1  2
# 0     1  <NA>  2
# 1     2     3  5
# 2  <NA>     4  6
print(df.dropna())
#    0  1  2
# 1  2  3  5

df = pd.DataFrame([[1, pd.NA, 2], [2, 3, 5], [pd.NA, 4, 6]])
print(df)
#       0     1  2
# 0     1  <NA>  2
# 1     2     3  5
# 2  <NA>     4  6
print(df.dropna(axis=1))
#    2
# 0  2
# 1  5
# 2  6

df = pd.DataFrame([[1, pd.NA, 2], [pd.NA, pd.NA, 5], [pd.NA, pd.NA, pd.NA]])
print(df)
#       0     1     2
# 0     1  <NA>     2
# 1  <NA>  <NA>     5
# 2  <NA>  <NA>  <NA>
print(df.dropna(how="all"))  # 如果所有值都是缺失值,则删除这一行
#       0     1  2
# 0     1  <NA>  2
# 1  <NA>  <NA>  5
print(df.dropna(thresh=2))  # 如果至少有2个值不是缺失值,则保留这一行
#    0     1  2
# 0  1  <NA>  2

df = pd.DataFrame([[1, pd.NA, 2], [pd.NA, pd.NA, 5], [pd.NA, pd.NA, pd.NA]])
print(df)
#       0     1     2
# 0     1  <NA>     2
# 1  <NA>  <NA>     5
# 2  <NA>  <NA>  <NA>
print(df.dropna(subset=[0]))  # 如果0列有缺失值,则删除这一行
#    0     1  2
# 0  1  <NA>  2

df = pd.read_csv("data/weather_withna.csv")
print(df.fillna(0).tail())  # 使用固定值填充
#   
print(df.fillna({"temp_max": 60, "temp_min": -60}).tail())  # 使用字典来填充
#             date  precipitation  temp_max  temp_min  wind weather
# 1456  2015-12-27            NaN      60.0     -60.0   NaN     NaN
# 1457  2015-12-28            NaN      60.0     -60.0   NaN     NaN
# 1458  2015-12-29            NaN      60.0     -60.0   NaN     NaN
# 1459  2015-12-30            NaN      60.0     -60.0   NaN     NaN
# 1460  2015-12-31           20.6      12.2       5.0   3.8    rain

print(df.fillna(df[["precipitation", "temp_max", "temp_min", "wind"]].mean()).tail())  # 使用平均值填充
#             date  precipitation   temp_max  temp_min      wind weather
# 1456  2015-12-27       3.052332  15.851468  7.877202  3.242055     NaN
# 1457  2015-12-28       3.052332  15.851468  7.877202  3.242055     NaN
# 1458  2015-12-29       3.052332  15.851468  7.877202  3.242055     NaN
# 1459  2015-12-30       3.052332  15.851468  7.877202  3.242055     NaN
# 1460  2015-12-31      20.600000  12.200000  5.000000  3.800000    rain

print(df.ffill().tail())  # 使用前面的有效值填充
#             date  precipitation  temp_max  temp_min  wind weather
# 1456  2015-12-27            0.0      11.1       4.4   4.8     sun
# 1457  2015-12-28            0.0      11.1       4.4   4.8     sun
# 1458  2015-12-29            0.0      11.1       4.4   4.8     sun
# 1459  2015-12-30            0.0      11.1       4.4   4.8     sun
# 1460  2015-12-31           20.6      12.2       5.0   3.8    rain
print(df.bfill().tail())  # 使用后面的有效值填充
#             date  precipitation  temp_max  temp_min  wind weather
# 1456  2015-12-27           20.6      12.2       5.0   3.8    rain
# 1457  2015-12-28           20.6      12.2       5.0   3.8    rain
# 1458  2015-12-29           20.6      12.2       5.0   3.8    rain
# 1459  2015-12-30           20.6      12.2       5.0   3.8    rain
# 1460  2015-12-31           20.6      12.2       5.0   3.8    rain

import pandas as pd
import numpy as np
# 创建包含缺失值的 Series
s = pd.Series([1, np.nan, 3, 4, np.nan, 6])
# 使用默认的线性插值方法填充缺失值
s_interpolated = s.interpolate()
print(s_interpolated)
# 0    1.0
# 1    2.0
# 2    3.0
# 3    4.0
# 4    5.0
# 5    6.0
# dtype: float64

- `'linear'`：线性插值，基于两点之间的直线来估算缺失值，适用于数据呈线性变化的情况。
- `'time'`：适用于时间序列数据，会考虑时间间隔进行插值。
- `'polynomial'`：多项式插值，通过拟合多项式曲线来估算缺失值，可通过 order 参数指定多项式的阶数。

# 缺失值
import numpy as np
import pandas as pd
# 缺失值的类型 nan na
s = pd.Series([np.nan, None, pd.NA,2,4])
df = pd.DataFrame([[1, pd.NA, 2], [2, 3, 5], [pd.NA, 4, 6]])
print(s)
print(s.isnull())  #查看是否是缺失值
print(s.isna()) #查看是否是缺失值
print(s.isna().sum()) # 缺失值的个数
# 剔除缺失值
print(s.dropna())  #series剔除缺失值
print(df.dropna()) #只要有缺失值，就剔除一整条记录
print(df.dropna(how="all")) # 如果所有值都是缺失值,则删除这一行
print(df.dropna(thresh=2)) # 如果至少有2个值不是缺失值,则保留这一行
print(df.dropna(axis=1))  #剔除一列中含缺失值的列
#可以通过设置subset参数来设置某一列有缺失值则进行剔除。
print(df.dropna(subset=[0]))# 如果0列有缺失值,则删除这一行
#填充缺失值
print('********')
df = pd.read_csv("data/weather_withna.csv")
# df = df.fillna({"temp_max": 60, "temp_min": -60}) # 使用字典来填充
print(df['temp_max'].mean())
df.fillna(df[["precipitation", "temp_max", "temp_min", "wind"]].mean()).tail() # 使用平均值填充
print(df.ffill().tail()) # 使用前面的有效值填充
print(df.bfill().tail()) # 使用后面的有效值填充

df1 = pd.read_csv("data/weather_withna.csv")
df2 = pd.read_csv("data/weather_withna.csv", keep_default_na=False)
print(df1.temp_max.count())
print(df1.isnull().sum())
print(df2.temp_max.count())
print(df2.isnull().sum())

import pandas as pd

# 创建包含重复数据的DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'Age': [25, 30, 25, 35, 30],
    'City': ['NY', 'LA', 'NY', 'SF', 'LA']
}
df = pd.DataFrame(data)

# 检测重复行（默认检查所有列）
print("重复行标记（False表示首次出现，True表示重复）：")
print(df.duplicated())
# 0    False
# 1    False
# 2     True
# 3    False
# 4     True
# dtype: bool

import pandas as pd

# 创建包含重复数据的DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'Age': [25, 30, 25, 35, 30],
    'City': ['NY', 'LA', 'NY', 'SF', 'LA']
}
df = pd.DataFrame(data)
# 默认保留首次出现的行
df_unique = df.drop_duplicates()
print("去重后的DataFrame：")
print(df_unique)

import pandas as pd

# 创建包含重复数据的DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'Age': [25, 30, 25, 35, 30],
    'City': ['NY', 'LA', 'NY', 'SF', 'LA']
}
df = pd.DataFrame(data)
# 仅根据'Name'列去重（保留首次出现）
df_name_unique = df.drop_duplicates(subset=['Name'])
print("按Name列去重：")
print(df_name_unique)
#       Name  Age City
# 0    Alice   25   NY
# 1      Bob   30   LA
# 3  Charlie   35   SF

import pandas as pd

# 创建包含重复数据的DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'Age': [25, 30, 25, 35, 30],
    'City': ['NY', 'LA', 'NY', 'SF', 'LA']
}
# 保留最后一次出现的行
df_last = df.drop_duplicates(keep='last')
print("保留最后一次出现的行：")
print(df_last)
#       Name  Age City
# 2    Alice   25   NY
# 4      Bob   30   LA
# 3  Charlie   35   SF

import pandas as pd

# 加载数据（以sleep.csv为例）
df = pd.read_csv("sleep.csv")
print(df.dtypes)
# person_id                     int64
# gender                       object
# age                           int64
# occupation                   object
# sleep_duration              float64
# sleep_quality               float64
# ...                          ...

# 将sleep_duration从float转为int（丢失小数部分）
df['sleep_duration_int'] = df['sleep_duration'].astype('int32')

# 将gender转为字符串
df['gender_str'] = df['gender'].astype('str')

print(df[['sleep_duration', 'sleep_duration_int', 'gender_str']].head())
#    sleep_duration  sleep_duration_int gender_str
# 0             7.4                  7       Male
# 1             4.2                  4     Female
# 2             6.1                  6       Male

# 示例：创建临时日期列（实际数据可能为hire_date）
df_employees = pd.read_csv("employees.csv")
df_employees['fake_date'] = '2023-01-' + df_employees['employee_id'].astype(str).str[:2]

# 转换为datetime
df_employees['fake_date'] = pd.to_datetime(df_employees['fake_date'])
print(df_employees[['employee_id', 'fake_date']].head())
#    employee_id  fake_date
# 0          100 2023-01-10
# 1          101 2023-01-10
# 2          102 2023-01-10

# 将gender列转为分类类型
df['gender'] = df['gender'].astype('category')
print(df['gender'].dtypes)
# category

# 保留sleep_quality的2位小数
df['sleep_quality_rounded'] = df['sleep_quality'].round(2)
print(df[['sleep_quality', 'sleep_quality_rounded']].head())
#    sleep_quality  sleep_quality_rounded
# 0            7.0                   7.00
# 1            4.9                   4.90
# 2            6.0                   6.00

df['age'] = pd.to_numeric(df['age'], errors='coerce')

df['age'] = df['age'].astype('int32')

df['is_active'] = df['active_flag'].map({'Yes': True, 'No': False})

df['score_percent'] = df['score'].apply(lambda x: f"{x*100:.1f}%")

#数据变形
import pandas as pd
data = {
    'ID': [1, 2],
    'name':['alice','bob'],
    'Math': [90, 85],
    'English': [88, 92],
    'Science': [95, 89]
}
df = pd.DataFrame(data)
df
df.T
#宽表转长表
df2= pd.melt(df, id_vars=['ID','name'], var_name='科目', value_name='分数')
df2.sort_values(by=['name','科目'])
#长表转宽表
df3=pd.pivot(df2,index=['ID','name'],columns=['科目'],values='分数')
#分列
data = {
    'ID': [1, 2],
    'name':['alice smith','bob jack'],
    'Math': [90, 85],
    'English': [88, 92],
    'Science': [95, 89]
}
df = pd.DataFrame(data)
df[['first name','last name']] = df['name'].str.split(' ',expand=True)
# 加载数据
df = pd.read_csv("data/sleep.csv")

df=df[['person_id','blood_pressure']]
df[['high','low']]=df['blood_pressure'].str.split('/',expand=True)
df

import pandas as pd
d = pd.Timestamp( "2015-05-01 09:08:07.123456" )
# 属性
print('年：',d.year)
print('月：',d.month)
print('日：',d.day)
print('小时：',d.hour)
print('分钟：',d.minute)
print('秒：',d.second)
print('微秒：',d.microsecond)
print('季度：',d.quarter)
print('是否是月底：',d.is_month_end)
print('是否是月初：',d.is_month_start)
print('是否是年底：',d.is_year_end)
print('是否是年初：',d.is_year_start)
# 方法
print('星期几：',d.day_name())
print('转换为年度：',d.to_period("Y"))
print('转换为季度：',d.to_period("Q"))
print('转换为月度：',d.to_period("M"))
print('转换为季度：',d.to_period("Q"))
print('转换为周维度：',d.to_period("W"))

import pandas as pd

# 字符串字段转换为日期类型
a = pd.to_datetime('2025-07-01')
a = pd.to_datetime('20250409')
a = pd.to_datetime('2025/04/13')
a = pd.to_datetime('2025-07')
print(a)
print(type(a))
# dateFrame中的日期转换
df = pd.DataFrame({
    'sales':[100,50,40],
    'date':['2025-01-01','2023-03-02','2025-03-09']
})
df['datetime'] = pd.to_datetime(df['date'])
print(type(df['datetime'].dt))
df['datetime'].dt.day_name()

df = pd.read_csv("data/weather.csv")df["date"] = pd.to_datetime(df["date"])  # 将date列转换为datetime64类型
df.set_index("date", inplace=True)  # 将date列设置为索引，inplace=true直接修改原对象
df.info()# <class 'pandas.core.frame.DataFrame'>
# DatetimeIndex: 1461 entries, 2012-01-01 to 2015-12-31

print(df.loc["2013-01":"2013-06"])  # 获取2013年1~6月的数据
#             precipitation  temp_max  temp_min  wind weather
# date
# 2013-01-01            0.0       5.0      -2.8   2.7     sun
# 2013-01-02            0.0       6.1      -1.1   3.2     sun
# ...                   ...       ...       ...   ...     ...
# 2013-06-29            0.0      30.0      18.3   1.7     sun
# 2013-06-30            0.0      33.9      17.2   2.5     sun
print  (  df  .  loc  [  "2015"  ])    # 获取2015年所有数据
#             precipitation  temp_max  temp_min  wind weather
# date
# 2015-01-01            0.0       5.6      -3.2   1.2     sun
# 2015-01-02            1.5       5.6       0.0   2.3    rain
# ...                   ...       ...       ...   ...     ...
# 2015-12-30            0.0       5.6      -1.0   3.4     sun
# 2015-12-31            0.0       5.6      -2.1   3.5     sun

df.between_time("9:00", "11:00")  # 获取9:00到11:00之间的数据
df.at_time("3:33")  # 获取3:33的数据

d1 = pd.Timestamp( "2015-05-01 09:08:07.123456" )
d2 = pd.Timestamp( "2015-05-31 09:23:07.123456" )
print(d2-d1)
print(type(d1))
print(type(d2-d1))

df = pd.read_csv("data/weather.csv", parse_dates=[0])
df_date   =   pd  .  to_datetime  (  df  [  "date"  ])
df  [  "timedelta"  ] =   df_date     -     df_date  [  0  ]    # 得到timedelta64类型的数据
df  .  set_index  (  "timedelta"  ,   inplace  =  True  )    # 将timedelta列设置为索引
df  .  info  ()# <class 'pandas.core.frame.DataFrame'>
# TimedeltaIndex: 1461 entries, 0 days to 1460 days

print(df.loc["0 days":"5 days"])
#                 date  precipitation  temp_max  temp_min  wind  weather
# timedelta
# 0 days    2012-01-01            0.0      12.8       5.0   4.7  drizzle
# 1 days    2012-01-02           10.9      10.6       2.8   4.5     rain
# 2 days    2012-01-03            0.8      11.7       7.2   2.3     rain
# 3 days    2012-01-04           20.3      12.2       5.6   4.7     rain
# 4 days    2012-01-05            1.3       8.9       2.8   6.1     rain
# 5 days    2012-01-06            2.5       4.4       2.2   2.2     rain

print(pd.date_range("2015-07-03", "2015-07-10"))
# DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-05', '2015-07-06',
#                '2015-07-07', '2015-07-08', '2015-07-09', '2015-07-10'],
#               dtype='datetime64[ns]', freq='D')

print(pd.date_range("2015-07-03", periods=5))  
# DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-05', '2015-07-06',
#                '2015-07-07'],
#               dtype='datetime64[ns]', freq='D')

print(pd.date_range("2015-07-03", periods=5, freq="h"))
  # DatetimeIndex(['2015-07-03 00:00:00', '2015-07-03 01:00:00',
  #                '2015-07-03 02:00:00', '2015-07-03 03:00:00',
  #                '2015-07-03 04:00:00'],
  #               dtype='datetime64[ns]', freq='h')

print  (  pd  .  date_range  (  "2015-07-03"  ,   periods  =  10  ,   freq  =  "QE-JAN"  ))
  # 设置1月为季度末
  # DatetimeIndex(['2015-07-31', '2015-10-31', '2016-01-31', '2016-04-30',
  #                '2016-07-31', '2016-10-31', '2017-01-31', '2017-04-30',
  #                '2017-07-31', '2017-10-31'],
  #               dtype='datetime64[ns]', freq='QE-JAN')

print  (  pd  .  date_range  (  "2015-07-03"  ,   periods  =  10  ,   freq  =  "W-WED"  ))
  # 设置周三为一周的第一天
  # DatetimeIndex(['2015-07-08', '2015-07-15', '2015-07-22', '2015-07-29',
  #                '2015-08-05', '2015-08-12', '2015-08-19', '2015-08-26',
  #                '2015-09-02', '2015-09-09'],
  #               dtype='datetime64[ns]', freq='W-WED')

print  (  pd  .  date_range  (  "2015-07-03"  ,   periods  =  10  ,   freq  =  "2h30min"  )) 
  # DatetimeIndex(['2015-07-03 00:00:00', '2015-07-03 02:30:00',
  #                '2015-07-03 05:00:00', '2015-07-03 07:30:00',
  #                '2015-07-03 10:00:00', '2015-07-03 12:30:00',
  #                '2015-07-03 15:00:00', '2015-07-03 17:30:00',
  #                '2015-07-03 20:00:00', '2015-07-03 22:30:00'],
  #               dtype='datetime64[ns]', freq='150min')

# 示例：分析高波动品类（闭环流程）
grouped = df.groupby('category') 
# 1. 描述性统计 → 2. 分组过滤 → 3. 分组转换
result = (grouped.filter(lambda x: x['price'].std() > 2)
          .groupby('category')['price']
          .transform(lambda x: (x - x.mean())/x.std()))

print(df.groupby("department_id").groups)  # 查看分组结果
# {10.0: [100], 20.0: [101, 102], 30.0: [14, 15, 16, 17, 18, 19]...

print(df.groupby("department_id").get_group(50))  
# 获取分组为50的数据
#     employee_id first_name    last_name     email...
# 20          120    Matthew        Weiss    MWEISS...
# 21          121       Adam        Fripp    AFRIPP...
# 22          122      Payam     Kaufling  PKAUFLIN...

print(df.groupby("department_id")["salary"])  
# 按department_id分组，取salary列
# <pandas.core.groupby.generic.SeriesGroupBy object at 0x0000022456D6F2F0>

print(df.groupby("department_id")["salary"].mean())  
# 计算每个部门平均薪资
# department_id
# 10.0      4400.000000
# 20.0      9500.000000
# 30.0      4150.000000

for dept_id,group in df.groupby("department_id"):
    print(f"当前组为{dept_id}，组里的数据情况{group.shape}:")
    print(group.iloc[:,0:3])
    print("-------------------")
# 当前组为10.0，组里的数据情况(1, 10):
#      employee_id first_name last_name
# 100          200   Jennifer    Whalen
# -------------------
# 当前组为20.0，组里的数据情况(2, 10):
#      employee_id first_name  last_name
# 101          201    Michael  Hartstein
# 102          202        Pat        Fay

salary_mean = df.groupby(["department_id", "job_id"])[
   ["salary", "commission_pct"]
].mean()  # 按department_id和job_id分组
print(salary_mean.index)  # 查看分组后的索引
# MultiIndex([( 10.0,    'AD_ASST'),
#             ( 20.0,     'MK_MAN'),
#             ( 20.0,     'MK_REP'),
#             ( 30.0,   'PU_CLERK'),
#             ( 30.0,     'PU_MAN'),
#             ...
print(salary_mean.columns)  # 查看分组后的列
# Index(['salary', 'commission_pct'], dtype='object')

print(salary_mean.reset_index())
#     department_id      job_id        salary  commission_pct
# 0            10.0     AD_ASST   4400.000000             NaN
# 1            20.0      MK_MAN  13000.000000             NaN
# 2            20.0      MK_REP   6000.000000             NaN
# 3            30.0    PU_CLERK   2780.000000             NaN
# 4            30.0      PU_MAN  11000.000000             NaN

salary_mean = df.groupby(["department_id", "job_id"], as_index=False)[
    ["salary", "commission_pct"]
].mean()  # 按department_id和job_id分组
print(salary_mean)#     department_id      job_id        salary  commission_pct
# 0            10.0     AD_ASST   4400.000000             NaN
# 1            20.0      MK_MAN  13000.000000             NaN
# 2            20.0      MK_REP   6000.000000             NaN
# 3            30.0    PU_CLERK   2780.000000             NaN
# 4            30.0      PU_MAN  11000.000000             NaN

df.groupby("month")["weather"].nunique()
# date
# 2012-01    4
# 2012-02    4
# 2012-03    4
# 2012-04    4
# 2012-05    3

df = pd.read_csv("data/employees.csv")  # 读取员工数据
# 按department_id分组，计算salary的最小值，中位数，最大值
print(df.groupby("department_id")["salary"].agg(["min", "median", "max"]))#                    min   median      max
# department_id
# 10.0            4400.0   4400.0   4400.0
# 20.0            6000.0   9500.0  13000.0
# 30.0            2500.0   2850.0  11000.0
# 40.0            6500.0   6500.0   6500.0
# 50.0            2100.0   3100.0   8200.0

df = pd.read_csv("data/employees.csv")  # 读取员工数据
# 按department_id分组，统计job_id的种类数，commission_pct的平均值
print(df.groupby("department_id").agg({"job_id": "nunique", "commission_pct": "mean"}))
#                job_id  commission_pct
# 10.0                1             NaN
# 20.0                2             NaN
# 30.0                2             NaN
# 40.0                1             NaN
# 50.0                3             NaN

df = pd.read_csv("data/employees.csv")  # 读取员工数据
# 按department_id分组，统计job_id的种类数，commission_pct的平均值
print(
    df.groupby("department_id")
    .agg(
        {"job_id": "nunique", "commission_pct": "mean"},
    )
    .rename(
        columns={"job_id": "工种数", "commission_pct": "佣金比例平均值"},
    )
)
#                工种数  佣金比例平均值
# department_id
# 10.0             1      NaN
# 20.0             2      NaN
# 30.0             2      NaN
# 40.0             1      NaN
# 50.0             3      NaN

df = pd.read_csv("data/employees.csv")  # 读取员工数据
def f(x):
    """统计每个部门员工last_name的首字母"""    result = set()
    for i in x:
        result.add(i[0])
    return result
print(df.groupby("department_id")["last_name"].agg(f))
# department_id
# 10.0                                                   {W}
# 20.0                                                {F, H}
# 30.0                                    {B, T, R, C, K, H}
# 40.0                                                   {M}
# 50.0     {O, E, K, S, W, L, P, D, C, V, B, T, M, J, F, ...

df = pd.read_csv("data/employees.csv")  # 读取员工数据
print(df.groupby("department_id")["salary"].transform(lambda x: x - x.mean()))

df = pd.read_csv("data/employees.csv")  # 读取员工数据
na_index = pd.Series(df.index.tolist()).sample(30)  # 随机挑选30条数据
df.loc[na_index, "salary"] = pd.NA  # 将这30条数据的salary设置为缺失值
print(df.groupby("department_id")["salary"].agg(["size", "count"]))  # 查看每组数据总数与非空数据数
def fill_missing(x):
    # 使用平均值填充，如果平均值也为NaN，用0填充    
    if np.isnan(x.mean()):
        return 0    
    return x.fillna(x.mean())
df["salary"] = df.groupby("department_id")["salary"].transform(fill_missing)
print(df.groupby("department_id")["salary"].agg(["size", "count"]))  # 查看每组数据总数与非空数据数

commission_pct_filter = df.groupby("department_id").filter(lambda x: x["commission_pct"].notnull().all()
)  # 按department_id分组，过滤掉commission_pct包含空值的分组
print(commission_pct_filter)

import matplotlib.pyplot as plt
from matplotlib import rcParams
# rcParams['font.sans-serif'] = 'STHeiti'  # 设置中文字体

plt.figure(figsize=(10, 5))
month = ['1月', '2月', '3月', '4月']
sales = [100, 150, 80, 130]

plt.plot(month, sales,
         label='产品A',
         color='orange',
         linewidth=2,
         linestyle='--',
         marker='o')

plt.title('2025年销售趋势', color='red', fontsize=20)
plt.xlabel('月份', fontsize=10)
plt.ylabel('销售额（万元）', fontsize=10)
plt.legend(loc='upper left')
plt.grid(True, alpha=0.1, color='blue', linestyle='--')
plt.show()

import matplotlib.pyplot as plt
from matplotlib import rcParams
# rcParams['font.sans-serif'] = 'STHeiti'

plt.figure(figsize=(10, 5))
subjects = ['语文', '数学', '英语', '科学']
scores = [85, 92, 78, 88]

plt.bar(subjects, scores,
        label='小红',
        color='orange',
        width=0.6)

plt.title('2025年成绩分布', color='red', fontsize=20)
plt.xlabel('科目', fontsize=10)
plt.ylabel('分数', fontsize=10)
plt.legend(loc='upper right')
plt.grid(axis='y', alpha=0.1, color='blue', linestyle='--')
plt.ylim(0, 100)

# 在每个柱子上显示数值
for x, y in zip(subjects, scores):
    plt.text(x, y+1, str(y), ha='center', va='bottom', fontsize=10)

plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt
from matplotlib import rcParams
# rcParams['font.sans-serif'] = 'STHeiti'

plt.figure(figsize=(10, 5))
things = ['学习', '娱乐', '运动', '睡觉', '其他']
times = [6, 4, 1, 8, 5]
colors = ['#66b3ff', '#99ff99', '#ffcc99', '#ff9999', '#ff4499']
explode = [0.1, 0, 0, 0, 0]  # 突出显示第一块

plt.pie(times, labels=things,
        autopct='%.1f%%',  # 显示百分比
        startangle=0,
        colors=colors,
        explode=explode,
        shadow=True)

plt.title('一天的时间分布', color='red', fontsize=20)
plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt
from matplotlib import rcParams
# rcParams['font.sans-serif'] = 'STHeiti'

plt.figure(figsize=(10, 5))
scores = [50, 55, 60, 65, 70, 75, 80]
hours = [1, 2, 3, 4, 5, 6, 7]

plt.scatter(hours, scores,
            s=100,  # 点的大小
            c='blue',
            alpha=0.6,
            marker='o')

plt.title('学习时间与成绩关系', fontsize=16)
plt.xlabel('学习时间（小时）', fontsize=12)
plt.ylabel('成绩', fontsize=12)
plt.grid(True, alpha=0.3)
plt.show()

import matplotlib.pyplot as plt
from matplotlib import rcParams
# rcParams['font.sans-serif'] = 'STHeiti'

plt.figure(figsize=(8, 6))

# 模拟3门课的成绩
data = {
    '语文': [82, 85, 88, 70, 90, 76, 84, 83, 95],
    '数学': [75, 80, 79, 93, 88, 82, 87, 89, 92],
    '英语': [70, 72, 68, 65, 78, 80, 85, 90, 95]
}

plt.boxplot(data.values(), tick_labels=data.keys())

plt.title('各科成绩分布（箱线图）', fontsize=16)
plt.ylabel('分数', fontsize=12)
plt.grid(True, axis='y', linestyle='--', alpha=0.5)
plt.show()

import matplotlib.pyplot as plt

# 创建图形和坐标轴对象
fig, ax = plt.subplots(figsize=(10, 5))

# 使用 ax 对象绘图
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
ax.set_title('标题')
ax.set_xlabel('X轴')
ax.set_ylabel('Y轴')
ax.grid(True)

plt.show()

import matplotlib.pyplot as plt

# 创建2x2的子图
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 第一个子图：折线图
axes[0, 0].plot([1, 2, 3, 4], [1, 4, 2, 3])
axes[0, 0].set_title('折线图')

# 第二个子图：柱状图
axes[0, 1].bar(['A', 'B', 'C'], [10, 20, 15])
axes[0, 1].set_title('柱状图')

# 第三个子图：散点图
axes[1, 0].scatter([1, 2, 3, 4], [1, 4, 2, 3])
axes[1, 0].set_title('散点图')

# 第四个子图：饼图
axes[1, 1].pie([30, 25, 45], labels=['A', 'B', 'C'])
axes[1, 1].set_title('饼图')

plt.tight_layout()  # 自动调整布局
plt.show()

from matplotlib import rcParams
rcParams['font.sans-serif'] = 'STHeiti'  # Mac
# rcParams['font.sans-serif'] = 'SimHei'  # Windows

plt.savefig('figure.png', dpi=300, bbox_inches='tight')

plt.clf()    # 清除当前图形
plt.close()  # 关闭图形窗口

plt.tight_layout()  # 自动调整子图布局，避免重叠

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

plt.rcParams["font.sans-serif"] = ["KaiTi"]
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)
penguins.info()
# <class 'pandas.core.frame.DataFrame'>
# Index: 333 entries, 0 to 343
# Data columns (total 7 columns):
#  #   Column             Non-Null Count  Dtype
# ---  ------             --------------  -----
#  0   species            333 non-null    object
#  1   island             333 non-null    object
#  2   bill_length_mm     333 non-null    float64
#  3   bill_depth_mm      333 non-null    float64
#  4   flipper_length_mm  333 non-null    float64
#  5   body_mass_g        333 non-null    float64
#  6   sex                333 non-null    object
# dtypes: float64(4), object(3)
# memory usage: 20.8+ KB

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 分类变量的计数
sns.histplot(data=penguins, x="species")
plt.title('企鹅种类分布')
plt.show()

# 数值变量的分布
sns.histplot(data=penguins, x="bill_length_mm")
plt.title('喙长度分布')
plt.xlabel('喙长度 (mm)')
plt.ylabel('频数')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
# plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 绘制喙长度的核密度估计图
sns.kdeplot(data=penguins, x="bill_length_mm")
plt.title('喙长度核密度估计图')
plt.xlabel('喙长度 (mm)')
plt.ylabel('密度')
plt.show()

# 直方图 + KDE 曲线
sns.histplot(data=penguins, x="bill_length_mm", kde=True)
plt.title('喙长度分布（直方图+KDE）')
plt.xlabel('喙长度 (mm)')
plt.ylabel('频数')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 绘制不同岛屿企鹅数量的计数图
sns.countplot(data=penguins, x="island")
plt.title('不同岛屿企鹅数量')
plt.xlabel('岛屿')
plt.ylabel('数量')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 绘制横轴为体重，纵轴为脚蹼长度的散点图
# 可通过hue参数设置不同组别进行对比
sns.scatterplot(data=penguins, x="body_mass_g", y="flipper_length_mm", hue="sex")
plt.title('体重与脚蹼长度关系')
plt.xlabel('体重 (g)')
plt.ylabel('脚蹼长度 (mm)')
plt.legend(title='性别')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 通过jointplot()函数，设置kind="hex"来绘制蜂窝图
sns.jointplot(data=penguins, x="body_mass_g", y="flipper_length_mm", kind="hex")
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 通过kdeplot()函数，同时设置x参数和y参数来绘制二维核密度估计图
sns.kdeplot(data=penguins, x="body_mass_g", y="flipper_length_mm")
plt.title('体重与脚蹼长度联合密度分布')
plt.xlabel('体重 (g)')
plt.ylabel('脚蹼长度 (mm)')
plt.show()

# 填充版本，显示颜色示意条
sns.kdeplot(data=penguins, x="body_mass_g", y="flipper_length_mm", fill=True, cbar=True)
plt.title('体重与脚蹼长度联合密度分布（填充版）')
plt.xlabel('体重 (g)')
plt.ylabel('脚蹼长度 (mm)')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 条形图
sns.barplot(data=penguins, x="species", y="bill_length_mm", estimator="mean", errorbar=None)
plt.title('不同种类企鹅的平均喙长度')
plt.xlabel('企鹅种类')
plt.ylabel('平均喙长度 (mm)')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 箱线图
sns.boxplot(data=penguins, x="species", y="bill_length_mm")
plt.title('不同种类企鹅的喙长度分布')
plt.xlabel('企鹅种类')
plt.ylabel('喙长度 (mm)')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 小提琴图
sns.violinplot(data=penguins, x="species", y="bill_length_mm")
plt.title('不同种类企鹅的喙长度分布（小提琴图）')
plt.xlabel('企鹅种类')
plt.ylabel('喙长度 (mm)')
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 加载数据（示例）
penguins = pd.read_csv("data/penguins.csv")
penguins.dropna(inplace=True)

# 成对关系图
sns.pairplot(data=penguins, hue="species")
plt.show()

pair_grid = sns.PairGrid(data=penguins, hue="species")

# 通过 map 方法在网格上绘制不同的图形
pair_grid.map_upper(sns.scatterplot)  # 上三角部分使用散点图
pair_grid.map_lower(sns.kdeplot)  # 下三角部分使用核密度估计图
pair_grid.map_diag(sns.histplot)  # 对角线部分使用直方图

# 设置样式
sns.set_style("whitegrid")  # 白色网格背景
sns.set_style("darkgrid")   # 深色网格背景
sns.set_style("white")      # 白色背景
sns.set_style("dark")       # 深色背景
sns.set_style("ticks")      # 带刻度的简洁样式

# 设置调色板
sns.set_palette("husl")     # 设置颜色主题
sns.set_palette("Set2")      # 使用预定义调色板

# 设置上下文（控制图表大小）
sns.set_context("paper")     # 论文大小
sns.set_context("notebook")  # 笔记本大小（默认）
sns.set_context("talk")      # 演讲大小
sns.set_context("poster")    # 海报大小

# 设置美观的默认样式
sns.set_style("whitegrid")
sns.set_palette("husl")
sns.set_context("notebook")

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'age': [20, 25, 30, 35, 40, 45, 50, 25, 30, 35, 40, 45, 30, 35, 40]
})

# 绘制单列的直方图
df['age'].plot(kind='hist', bins=20, title='年龄分布')
plt.xlabel('年龄')
plt.ylabel('频数')
plt.show()

# 等价写法
df['age'].hist(bins=20)
plt.title('年龄分布')
plt.xlabel('年龄')
plt.ylabel('频数')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'age': [20, 25, 30, 35, 40, 45, 50, 25, 30, 35, 40, 45, 30, 35, 40]
})

# 绘制密度图
df['age'].plot(kind='density', title='年龄密度分布')
plt.xlabel('年龄')
plt.ylabel('密度')
plt.show()

# 等价写法
df['age'].plot.kde()
plt.title('年龄密度分布')
plt.xlabel('年龄')
plt.ylabel('密度')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'age': [20, 25, 30, 35, 40, 45, 50, 25, 30, 35, 40, 45, 30, 35, 40]
})

# 绘制箱线图
df['age'].plot(kind='box', title='年龄分布箱线图')
plt.ylabel('年龄')
plt.show()

# 等价写法
df['age'].plot.box()
plt.title('年龄分布箱线图')
plt.ylabel('年龄')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'category': ['A', 'B', 'A', 'C', 'B', 'A', 'C', 'B', 'A', 'C']
})

# 绘制分类变量的计数图
df['category'].value_counts().plot(kind='bar', title='类别计数')
plt.xlabel('类别')
plt.ylabel('数量')
plt.xticks(rotation=0)
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'age': [25, 30, 35, 40, 45, 50, 28, 32, 38, 42],
    'salary': [5000, 6000, 8000, 10000, 12000, 15000, 5500, 7000, 9000, 11000]
})

# 绘制散点图
df.plot(x='age', y='salary', kind='scatter', title='年龄与薪资关系')
plt.xlabel('年龄')
plt.ylabel('薪资')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=10, freq='D'),
    'sales': [100, 120, 110, 130, 125, 140, 135, 150, 145, 160],
    'profit': [20, 25, 22, 28, 26, 30, 29, 35, 32, 38]
})

# 绘制折线图
df.plot(x='date', y='sales', kind='line', title='销售额趋势')
plt.xlabel('日期')
plt.ylabel('销售额')
plt.xticks(rotation=45)
plt.show()

# 多列折线图
df[['sales', 'profit']].plot(kind='line', title='销售额与利润趋势')
plt.xlabel('索引')
plt.ylabel('数值')
plt.legend(['销售额', '利润'])
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'category': ['A', 'B', 'C', 'D'],
    'value': [100, 150, 120, 180]
})

# 绘制条形图
df.plot(x='category', y='value', kind='bar', title='各类别数值')
plt.xlabel('类别')
plt.ylabel('数值')
plt.xticks(rotation=0)
plt.show()

# 水平条形图
df.plot(x='category', y='value', kind='barh', title='各类别数值（水平）')
plt.xlabel('数值')
plt.ylabel('类别')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'age': [25, 30, 35, 40, 45, 50, 28, 32, 38, 42],
    'salary': [5000, 6000, 8000, 10000, 12000, 15000, 5500, 7000, 9000, 11000],
    'bonus': [500, 600, 800, 1000, 1200, 1500, 550, 700, 900, 1100]
})

# 绘制多列的箱线图对比
df[['age', 'salary', 'bonus']].plot(kind='box', title='多变量箱线图对比')
plt.ylabel('数值')
plt.xticks(rotation=45)
plt.show()

import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["STHeiti"]

# 创建示例数据
df = pd.DataFrame({
    'sales': [100, 120, 110, 130, 125, 140, 135, 150],
    'profit': [20, 25, 22, 28, 26, 30, 29, 35]
})

# 绘制面积图
df[['sales', 'profit']].plot(kind='area', stacked=False, title='销售额与利润面积图')
plt.xlabel('索引')
plt.ylabel('数值')
plt.legend(['销售额', '利润'])
plt.show()