## 奇乐搜

是一个综合网盘搜索引擎，提供阿里云盘、夸克网盘的网盘资源搜索服务，支持投稿提交资源，可以按照24小时热门和一周热门等等方式查看，喜欢什么或者想要找什么资源直接搜索即可，使用无需注册登录，而且没有广告，非常不错的一个综合网盘搜索引擎。

互联网具有天然的资源共享性，该站不是资源的生产者，不存储任何资源，仅仅只是互联网的搬运工。

## 网站地址

[https://www.qileso.com/](https://www.qileso.com/)

## 类似网站

- 咔帕搜索：[https://www.cuppaso.com/](https://www.cuppaso.com/)
- 阿里搜：[https://aliso.cc/](https://aliso.cc/)
- SoAli：[https://soali.net/](https://soali.net/)
- 云盘4K：[https://www.codelicence.cn/](https://www.codelicence.cn/)
- 影盘社：[https://pan.melost.cn/](https://pan.melost.cn/)
- PanSou盘搜：https://so.252035.xyz/


奇乐搜-阿里云盘、夸克网盘综合搜索网站

## Memos

一项免费开源隐私优先的轻量级笔记服务应用，轻松捕捉和分享您的好主意。

主要特性：

- 开源且永久免费：Memos是一款开源的应用，永久免费使用。它鼓励创造力，让您的想法得以充分发挥，不受任何限制
- 自托管部署：使用Docker，可以在几秒钟内设置好Memos，获得数据和隐私的完全控制权，提供了极大的灵活性和可扩展性
- 纯文本与Markdown支持：Memos坚持采用纯文本格式，摒弃了繁琐的富文本编辑，同时支持Markdown，让您以极简主义的方式记录和分享笔记
- 自定义与轻松分享：Memos提供直观的自定义和分享功能，使你能够轻松地与他人合作和分享笔记，促进信息交流
- RESTful API支持：Memos还提供了强大的RESTful API，让您能够与第三方服务进行集成，开启全新的应用可能性

## 下载地址

官网：[https://www.usememos.com/](https://www.usememos.com/)


Memos-免费开源隐私优先的轻量级笔记服务应用

## Regex Learn

是一个开源项目，欢迎社区贡献和免费使用。参与这个项目可以帮助您磨炼技能、学习和协作。

逐步学习正则表达式，从零基础到高阶。学习正则比您想象的要容易得多，您可以使用本工具轻松学习、练习、测试和分享正则表达式。

## 网站地址

Regex Learn：[https://regexlearn.com/zh-cn](https://regexlearn.com/zh-cn)


Regex Learn-逐步学习正则表达式，从零基础到高阶

在了解完pandas的两种主要数据结构[Series序列](__GHOST_URL__/post/21/)与[DataFrame数据框](__GHOST_URL__/post/637/)，下面就来学习下pandas是怎么处理数据的。

处理数据一般分为几个阶段：数据整理与清洗、数据分析与建模、数据可视化，pandas是处理数据的理想工具。

## 缺失值处理

None是Python中自带的空对象。None不能参与任何计算，object类型的运算要比int类型的运算慢得多。

np.nan是浮点类型，能参与到计算中，但计算的结果总是NaN。可以使用np.nan*()函数来计算nan，此时会过滤掉nan。

在pandas中，None与np.nan都视作np.nan。

### 找到缺失值

找有空的列：`df.isnull().any()`，any只要有一个为True就为True，类似or。

找不为空的列：`df.notnull().all()`，all必须全部为True才会是True，类似and。

找有空的行：`df.isnull().any(axis=1)`。

找不为空的行：`df.notnull().all(axis=1)`。

### 行过滤

    cond = df.isnull().any(axis=1)
    print(df[~cond])
    # 或者
    cond = df.notnull().all(axis=1)
    print(df[cond])

### 列过滤

    cond = df.isnull().any()
    print(df.loc[:, ~cond])
    # 或者
    cond = df.notnull().all()
    print(df.loc[:, cond])

### dropna()

df.dropna()默认删除有空的行，删除有空的列使用df.dropna(axis=1)。也可以选择过滤的方式，默认how="any"，how="all"必须所有数据都为nan才会删除。参数inplace=True会修改原数据。

### 填充空值

    df.fillna(value=100)
    df.fillna(method="ffill")  # 向前填充，向后填充是bfill
    df.fillna(method="ffill",axis=1)  # 向左填充，向右填充是bfill

## 重复值处理

duplicated()函数用来检测重复行，返回元素为布尔类型的Series对象。

duplicated默认保留重复第一行，keep='last'保留重复最后一行，keep=False不保留重复行。

    df.duplicated(keep='first')
    df.duplicated(subset=["列名"])  # subset参数为列名，对指定列进行去重操作

使用drop_duplicates()函数删除重复行：`df.drop_duplicates(subset=["列名"], keep='last')`。

## 异常值处理

    print(df.describe([0.01, 0.5, 0.99]))  # 自定义百分位数
    print(df.describe([0.01, 0.5, 0.99]).T)  # 行列转置

Series唯一值：`print(df[0].unique())`。

按条件查询：

    data = [["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]]
    df = pd.DataFrame(data, columns=["a", "b", "c"])
    print(df.query("b==100"))  # 找到 b列=100 所有行
    print(df.query("b in [90,100]"))
    n = 100
    print(df.query("b ==@n"))  # 使用变量

排序：

    print(df.sort_values("b", ascending=False))  # 默认按列名升序排序，ascending=False 降序，axis=1 按行排序
    print(df.sort_index(ascending=False))  # 默认按索引升序排序，axis=1 按列索引排序

## 行列操作

### 添加行

    df = pd.DataFrame([["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]])
    df2 = pd.DataFrame([["Dick", 99, 77]])
    df3 = pd.concat([df, df2], ignore_index=True)  # 默认上下合并
    df4 = pd.concat([df, df2], keys=["a", "b"])  # keys添加多层索引

### 删除行

    data = [["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]]
    df = pd.DataFrame(data)
    df.drop(1, inplace=True)  # 默认删除行
    df.drop(1, axis=1, inplace=True)  # 删除列
    df.drop(index=[1, 2])  # 删除多行
    df.drop(columns=[1, 2])  # 删除多列

### 添加列

    data = [["Alex", 100], ["Bob", 91], ["Clarke", 82]]
    df = pd.DataFrame(data, columns=["Name", "Score_1"])
    df.insert(1, column="Score_2", value=[90, 80, 88])

### 删除列

    data = [["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]]
    df = pd.DataFrame(data, columns=["Name", "Score_1", "Score_2"])
    del df["Score_1"]  # 使用del删除
    df.pop("Name")  # 使用pop()方法删除

## 数据合并

### pd.concat()

外连接，类似并集，显示所有数据：

    def make_df(indexs, columns):
        """生成DataFrame"""
        data = [[str(j) + str(i) for j in columns] for i in indexs]
        df = pd.DataFrame(data, index=indexs, columns=columns)
        return df
    df1 = make_df([1, 2, 3, 4], list("ABCD"))
    df2 = make_df([5, 2, 3, 10], list("BCDE"))
    df3 = pd.concat([df1, df2])

内连接，类似交集，只连接匹配的项：`df3 = pd.concat([df1, df2], join="inner")`。

### merge()

也可以使用merge()合并数据，类似MySQL中表和表合并。merge与concat的区别在于，merge需要依据某一共同的行或列来进行合并。使用merge合并时，会自动根据两者相同column名称的那一列，作为key来进行合并，每一列元素的顺序不要求一致。

有多列名称相同，可指定一列作为连接字段：

    df1 = make_df([1, 2, 3], list("ABC"))
    df2 = make_df([2, 3, 4], list("BCD"))
    print(df1.merge(df2, on="C"))

可以配合suffixes参数指定冲突列名：

    df1 = make_df([1, 2, 3], list("ABC"))
    df2 = make_df([2, 3, 4], list("BCD"))
    print(df1.merge(df2, on="C", suffixes=["_df1", "_df2"]))

如果没有相同列名，需使用来指定2个表中的不同列作为连接字段：

    df1 = make_df([1, 2, 3], list("ABC"))
    df2 = make_df([2, 3, 4], list("BD"))
    print(df1.merge(df2, left_on="B", right_on="B"))

也可以使用行索引作为连接字段：

    df1 = make_df([1, 2, 3], list("ABC"))
    df2 = make_df([2, 3, 4], list("DE"))
    print(df1.merge(df2, left_index=True, right_index=True))

merge默认是内连接，可以使用how参数指定连接方式：

    df1 = make_df([1, 2, 3], list("ABC"))
    df2 = make_df([2, 3, 4], list("CD"))
    print(df1.merge(df2, how="outer"))

左连接：how="left"，右连接：how="right"。

## 数据映射

### 元素替换

使用replace函数，对values进行替换操作。

    import pandas as pd
    import numpy as np
    data = [{"Name": "Alex", "Age": 12}, {"Name": "Bob", "Age": 16, "Sex": "1"}]
    df = pd.DataFrame(data)
    df.replace({np.nan: 0}, inplace=True)

### map()函数

map一般用在Series数据结构，不能用于DataFrame，适合处理某一单独列，在map()函数中可以使用lambda。

    def fn(sex):
    if sex == "1":
    return "男"
    elif sex == "2":
    return "女"
    else:
    return ""
    data = [{"Name": "Alex", "Age": 12}, {"Name": "Bob", "Age": 16, "Sex": "1"}]
    df = pd.DataFrame(data)
    df["性别"] = df["Sex"].map(fn)

### apply()函数

既支持Series，也支持DataFrame。

    df["Age"] = df["Age"].apply(lambda x: "成年" if x >= 18 else "未成年")
    print(df.apply(lambda x: x.max()))  # 对每列操作
    print(df.applymap(lambda x: x + 100))  # 对所有DataFrame元素操作

### transform()函数

既支持Series，也支持DataFrame。

    print(df[1].transform([np.sqrt, np.exp]))  # 可以执行多项计算
    print(df.transform(lambda x: x + 10))  # 处理每一列
    print(df.transform(lambda x: x + 10, axis=1))  # 处理每一行

### 修改索引

替换索引：

    data = [{"Name": "Alex", "Age": 12}, {"Name": "Bob", "Age": 16, "Sex": "1"}]
    df = pd.DataFrame(data)
    df.rename(index={0: 10}, inplace=True)  # 修改行索引名
    df.rename(columns={"Name": "姓名"}, inplace=True)  # 修改列索引名

重置索引：`df.reset_index(inplace=True)`。

设置索引：`df.set_index(keys=["Age"], inplace=True)`。

## 数据筛选

    data = [["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]]
    df = pd.DataFrame(data, index=["one", "two", "three"], columns=["A", "B", "C"])
    f1 = df.filter(items=["A", "C"])  # 按名称选择列
    f2 = df.filter(regex="e$", axis=0)  # 按正则表达式选择列索引名以e结尾，axis=0表示对行操作
    f3 = df.filter(like="t", axis=0)  # 列索引名中含有t的
    f4 = df.filter(like="t", axis=0).filter(items="B")  # 连续筛选

## 抽样

使用take()函数排序，借助np.random.permutation()函数随机排序。

无放回抽样：

    data = [["Alex", 100, 90], ["Bob", 91, 80], ["Clarke", 82, 88]]
    df = pd.DataFrame(data, index=["one", "two", "three"], columns=["A", "B", "C"])
    print(df.take(np.random.permutation([0, 1, 2])))

有放回抽样：`print(df.take(np.random.randint(0, 3, size=6)))`。

## 分组聚合

    df = pd.DataFrame(
    {
    "color": ["red", "red", "blue", "yellow", "blue"],
    "price": [1, 3, 5, 6, 7],
    }
    )
    df2 = df.groupby("color").sum()  # 先按 color 进行分组，再聚合
    print(df2)

## 分箱操作

分箱操作就是将连续型数据离散化，分为等距分箱和等频分箱。

等距分箱：

    data = np.random.randint(0, 100, size=(5, 3))
    df = pd.DataFrame(data, columns=["A", "B", "C"])
    print(pd.cut(df.A, bins=4))
    bins 指定分箱断点。默认是左开右闭，right=False 左闭右开。参数labels指定分箱后分类的标签
    print(pd.cut(df.A, bins=[0, 60, 80, 90, 100], right=False, labels=["D", "C", "B", "A"]))

等频分箱：`pd.qcut(df.A, q=4, labels=["D", "C", "B", "A"])`。


Python数据分析模块pandas之数据处理

## 读取数据

    import pandas as pd
    data = pd.read_csv("天猫订单.csv")
    data.head()
    data.shape

## 数据处理

    data.info()  # 订单付款时间 24087 non-null
    data.columns
    data.columns = data.columns.str.strip()  # 去除列名中首尾空格

重复值查看:`data.duplicated().sum()`，重复数据：109

缺失值查看：`data.isnull().sum()`，缺失数据：订单付款时间 3923

## 数据可视化

### 各省订单量

    def province_map(p):
    if p in ["北京", "天津", "上海", "重庆"]:
    return p + "市"
    return p
    data.收货地址 = data.收货地址.map(province_map)
    统计各省订单量，去除没有付款的订单数据
    result = data[data.订单付款时间.notnull()]
    统计各省订单量
    result2 = result.groupby("收货地址")[["订单编号"]].count().to_dict()["订单编号"]
    from pyecharts import options as opts
    from pyecharts.charts import Bar, Line, Map, Pie, Timeline
    from pyecharts.globals import CurrentConfig, NotebookType
    不同notebook坏境有不同渲染要求，pyecharts在底层做了适配处理
    但因为无法在import pyecharts时知道具体使用哪种noteboook坏境，所以需要在使用时声明坏境类型
    CurrentConfig.NOTEBOOK_TYPE = NotebookType.JUPYTER_LAB
    c = (
    Map()
    .add("各省订单量", [*result2.items()], "china", is_map_symbol_show=False)
    .set_series_opts(label_opts=opts.LabelOpts(is_show=True))
    .set_global_opts(
    title_opts=opts.TitleOpts(title="各省订单量"),
    visualmap_opts=opts.VisualMapOpts(max_=2000),
    )
    )
    c.load_javascript()  # 第一次渲染，要调用load_javascript方法
    c.render_notebook()

### 时间序列分析

    # 转成时间类型
    data.订单创建时间 = pd.to_datetime(data.订单创建时间)
    data.订单付款时间 = pd.to_datetime(data.订单付款时间)

#### 每天订单量

    order_add_time = data.订单创建时间.map(lambda x: x.strftime("%Y-%m-%d"))
    result3 = data.groupby(order_add_time).agg({"订单编号": "count"}).to_dict()["订单编号"]
    result3
    c = (
    Line()
    .add_xaxis(list(result3.keys()))
    .add_yaxis("订单量", list(result3.values()))
    .set_series_opts(
    label_opts=opts.LabelOpts(is_show=False),
    markpoint_opts=opts.MarkAreaOpts(data=[opts.MarkPointItem(type_="max")]),
    )
    .set_global_opts(title_opts=opts.TitleOpts(title="每天订单量"))
    )
    c.render_notebook()

#### 每小时订单量

    order_add_time2 = data.订单创建时间.map(lambda x: x.strftime("%H"))
    result4 = data.groupby(order_add_time2).agg({"订单编号": "count"}).to_dict()["订单编号"]
    result4
    c = (
    Bar()
    .add_xaxis(list(result4.keys()))
    .add_yaxis("订单量", list(result4.values()))
    .set_series_opts(
    label_opts=opts.LabelOpts(is_show=False),
    markpoint_opts=opts.MarkAreaOpts(data=[opts.MarkPointItem(type_="max")]),
    )
    .set_global_opts(title_opts=opts.TitleOpts(title="每小时订单量"))
    )
    c.render_notebook()


JupyterLab+pyecharts天猫订单数据可视化项目

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。