DataShare Blog

Python与Rust类型参数对比：从TypeVar到泛型T

Fri, 10 Apr 2026 00:00:00 GMT

一、相同的目标：占位符与泛化

无论是 Python 的 TypeVar 还是 Rust 的 <T>，它们的核心使命完全一致：

定义一个“尚不确定具体类型”的占位符，让同一套代码逻辑安全地适用于多种不同类型

# Python: 定义一个泛型函数
from typing import TypeVar

T = TypeVar('T')

def first(items: list[T]) -> T:
    return items[0]

// Rust: 定义一个泛型函数
fn first<T>(items: &[T]) -> &T {
    &items[0]
}

在两种语言中，类型检查器（Python 的 mypy ， Rust 的 rustc）都能根据调用上下文自动推导出 T 的具体类型，并保证返回类型与输入元素类型一致

二、语法演进：殊途同归

Python 的类型标注语法一直在向更简洁、更内聚的方向演化，而 Rust 从一开始就采用了现在这种高效的形式

对比维度	Python (`TypeVar`)	Rust 泛型参数
传统声明	`T = TypeVar('T')`<br>`class Stack(Generic[T]):`	`struct Stack<T> { ... }`
现代声明（3.12+）	`class Stack[T]:`	`struct Stack<T> { ... }`
函数定义	`def func[T](arg: T) -> T:`	`fn func<T>(arg: T) -> T { ... }`

可以看到，Python 3.12 引入的 PEP 695 语法已经让 Python 的泛型写法与 Rust 高度趋同——类型变量直接写在类名或函数名后的方括号内

三、类型约束：继承（Inheritance） vs. 特征（Trait）

这是两种语言泛型系统最核心的差异所在

Python：基于继承或协议的上界约束

Python 通过 bound 参数限定类型变量必须满足某个父类或协议（Protocol）

from typing import TypeVar, Protocol

class SupportsClose(Protocol):
    def close(self) -> None: ...

T = TypeVar('T', bound=SupportsClose)

def safe_close(obj: T) -> T:
    obj.close()
    return obj

约束依据：是不是某个类的子类，或者是否实现了特定的方法集（鸭子类型）
运行时行为：isinstance 可以检查继承关系，但 TypeVar 本身不参与运行时类型强制

Rust：基于 Trait 的行为约束

Rust 没有传统意义上的继承，类型能否用作泛型参数完全取决于它是否实现了指定的 Trait

use std::io::Write;

fn write_twice<T: Write>(mut writer: T) -> std::io::Result<()> {
    writer.write_all(b"hello")?;
    writer.write_all(b"world")?;
    Ok(())
}

约束依据：实现了哪些 Trait，Trait 是显式的“行为契约”，不是隐式的继承关系
编译时强制：如果传入的类型没有实现 Write，编译直接失败

学习提示：Python 的 bound=SomeProtocol 在思想上最接近 Rust 的 T: SomeTrait。可以把 Rust 的 Trait 理解为必须显式声明并实现的、编译期强制的 Python Protocol

四、型变（Variance）：显式声明 vs. 自动推导

型变（协变、逆变、不变）是理解容器类型间替换关系的关键，Python 与 Rust 对型变的处理方式差异巨大

Python：定义 `TypeVar` 时显式声明型变

from typing import TypeVar, Generic

T_co = TypeVar('T_co', covariant=True)      # 协变：只产出数据
T_contra = TypeVar('T_contra', contravariant=True)  # 逆变：只消费数据

如果希望 Reader[Dog] 可以赋值给 Reader[Animal]，必须将 T 标记为 covariant=True，为可协变的
默认行为是不变（既不协变也不逆变），这是最安全的默认值

Rust：编译器自动推导型变

Rust 的类型系统会分析泛型参数在结构体或枚举中的使用方式，自动决定其型变

struct Producer<T> {
    value: T,           // 只产出 T，编译器自动推导为协变
}

struct Consumer<T> {
    _marker: std::marker::PhantomData<fn(T)>, // 只消费 T，编译器自动推导为逆变
}

Rust 不需要（也不能）用关键字显式声明协变/逆变，这减少了心智负担
型变信息主要用于生命周期的协变/逆变，对普通类型参数影响较小

核心口诀对比：

Python：你需要自己声明型变（covariant/contravariant）

Rust：编译器帮你搞定，你只需关注类型是否被读（产出→协变）或被写（消费→逆变）

五、运行时存在性：类型擦除 vs. 单态化

这一点是两者运行时行为的根本区别，直接影响你对“泛型性能”的认知

特性	Python (`TypeVar`)	Rust 泛型
何时检查	静态类型检查器（mypy、pyright）	编译器（rustc）
运行时类型信息	完全擦除。`list[int]` 和 `list[str]` 在运行时都是 `list`。	单态化（Monomorphization）。为每个具体类型生成独立代码。
性能影响	零运行时开销（因为标注只是注释），但对运行速度无提升。	零成本抽象。运行时性能等同于手写的具体类型代码，无动态分发开销。
可否用 `isinstance` 检查	❌ 不可。`isinstance(obj, list[T])` 是无效的。	❌ 不可，但编译时静态分发已保证类型正确。

关键理解： Python 的泛型是给工具看的，运行时 Python 解释器根本不知道 T 是什么 Rust 的泛型是给编译器看的，编译后 Option<i32> 和 Option<String> 是完全不同的两套机器码

六、高级特性对照表

特性	Python	Rust
多个类型参数	`class Pair[K, V]:`	`struct Pair<K, V>`
常量泛型	❌ 不支持	`struct Array<T, const N: usize>`
可变长度类型参数	`TypeVarTuple`（用于 `*args` 类型）	通过元组或宏实现，无直接语法糖
高阶类型（泛型上的泛型）	`ParamSpec`（用于装饰器参数签名捕获）	通过关联类型（Associated Types）和泛型 trait 部分实现
幽灵类型标记	不需要（类型已擦除）	`PhantomData<T>` 用于标记未直接使用的类型参数

七、从 Python 到 Rust：学习路径建议

先理解 Python TypeVar 的作用域与约束：熟悉 bound 和 Protocol，它们是 Rust Trait 约束的心理映射
接受“编译时单态化”的概念：Python 里你写 def func[T](x: T) 只有一个函数对象；Rust 里会为每个 T 生成一份独立的机器码。这是 Rust 高性能的来源，也是二进制体积可能增大的原因
忘记 Python 的型变显式声明：在 Rust 中，你几乎不需要手动操心协变/逆变，编译器会帮你处理
掌握 Rust Trait 系统：如果说 Python 的 TypeVar 是“占位符”，那么 Rust 的 Trait 就是“准入证”。学好 Trait 是写好 Rust 泛型代码的关键

八、总结对比表

维度	Python (`TypeVar`)	Rust 泛型
定义方式	`T = TypeVar('T')` 或 `class C[T]`	`struct S<T>` 或 `fn f<T>`
类型约束	`bound=BaseClass` 或 `bound=Protocol`	`T: Trait`
型变控制	显式声明 `covariant` / `contravariant`	编译器自动推导
运行时行为	类型擦除，仅用于静态检查	单态化，零成本抽象
学习重心	理解继承、协议与型变规则	理解 Trait、所有权与单态化

掌握了 Python 的 TypeVar 和泛型思维，你已经拥有了理解 Rust 泛型系统的核心“元认知”。接下来只需要将“继承约束”切换为“Trait 约束”，将“运行时擦除”切换为“编译时单态化”，就能顺利迈入 Rust 的类型世界，可以利用已有的 Python 类型知识平滑过渡到 Rust 的泛型思维

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 装饰器的灵活实现：带参数与不带参数

Wed, 04 Feb 2026 00:00:00 GMT

背景

装饰器是Python中一种强大的语法糖，它允许我们在不修改原函数代码的情况下，为函数添加额外的功能。装饰器本质上是一个可调用对象，它接受一个函数作为输入，并返回一个新的函数。装饰器的使用方式非常灵活，既可以不带参数使用，也可以带参数使用

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

函数装饰器实现

我们先来看一个简单的函数装饰器实现：

import time

def delayed_start(func=None, *, duration=1):
    def decorator(_func):
        def wrapper(*args, **kwargs):
            print(f"Wait for {duration} seconds before starting...")
            time.sleep(duration)
            return _func(*args, **kwargs)
        return wrapper

    if func is None:
        return decorator
    else:
        return decorator(func)

这个装饰器可以以两种方式使用：

不带参数使用：当装饰器不带参数使用时，Python会直接将装饰的函数作为参数传递给 delayed_start

@delayed_start
def hello_no_arg(name="datashare"):
    print("from hello_no_arg, param name =", name)

等价于：

hello_no_arg = delayed_start(hello_no_arg)

带参数使用：当装饰器带参数使用时，Python会先调用装饰器函数，返回一个真正的装饰器，然后再用这个装饰器装饰函数

@delayed_start(duration=2)
def hello_with_arg(name="datashare"):
    print("from hello_with_arg, param name =", name)

等价于：

hello_with_arg = delayed_start(duration=2)(hello_with_arg)

实现原理

delayed_start函数的巧妙之处在于它通过检查 func参数是否为 None来判断装饰器的使用方式：

如果 func不是 None，说明是不带参数使用，直接返回 decorator(func)
如果 func是 None，说明是带参数使用，返回 decorator函数等待接收真正的函数参数

类装饰器实现

类装饰器通过实现 __call__方法来实现装饰器的功能。下面是带参数和不带参数的类装饰器实现：

from functools import wraps
import time

class Timer:
    def __init__(self, func=None, *, print_args=False):
        self.func = func
        self.print_args = print_args

    def __call__(self, *args, **kwargs):
        # 情况 1：@Timer(print_args=True)
        # 第一次 __call__，args[0] 是函数
        if self.func is None:
            func = args[0]
            return self._decorate(func)

        # 情况 2：@Timer
        # 或者已经绑定好函数，真正执行
        return self._decorate(self.func)(*args, **kwargs)

    def _decorate(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            st = time.perf_counter()
            ret = func(*args, **kwargs)

            if self.print_args:
                print(f'"{func.__name__}", args: {args}, kwargs: {kwargs}')

            print(f"time cost: {time.perf_counter() - st:.4f} seconds")
            return ret

        return wrapper

不带参数使用：

@Timer
def compute(x):
    time.sleep(1)
    return x * 2

当类装饰器不带参数使用时，Python会创建 Timer类的实例，并将 compute函数传递给 __init__方法。此时 self.func就是 compute函数。当我们调用 compute(10)时，实际上是调用 Timer实例的 __call__方法

带参数使用：

@Timer(print_args=True)
def compute2(x):
    time.sleep(1)
    return x * 3

当类装饰器带参数使用时，Python会先调用 Timer(print_args=True)创建实例，此时 self.func为 None。然后用这个实例去装饰 compute2函数，这相当于调用 Timer实例的 __call__方法，并将 compute2作为参数传入

两种实现方式的比较

特性	函数装饰器	类装饰器
代码简洁性	更简洁，适合简单的装饰逻辑	更复杂，但结构更清晰
状态管理	需要使用闭包或nonlocal变量	可以使用实例属性，更直观
可扩展性	适合简单的装饰功能	适合需要维护状态的复杂装饰器
可读性	对于简单场景更易读	对于复杂场景更易维护

实际应用场景

性能监控：如 Timer装饰器，用于测量函数执行时间
权限验证：检查用户是否有权限执行某个函数
日志记录：自动记录函数的调用和参数
缓存：实现函数结果的缓存，提高性能
重试机制：当函数执行失败时自动重试

最佳实践

使用 functools.wraps装饰器来保留原函数的元数据（如函数名、文档字符串等）
对于简单的装饰器，优先使用函数装饰器
对于需要维护状态的装饰器，考虑使用类装饰器
在设计带参数的装饰器时，确保同时支持带参数和不带参数的使用方式

总结

Python装饰器是一个强大而灵活的特性，它允许我们以非侵入式的方式增强函数的功能。通过掌握函数装饰器和类装饰器的实现方式，以及如何实现带参数和不带参数的装饰器，我们可以编写出更加通用和可重用的代码。无论是简单的函数增强还是复杂的状态管理，装饰器都能提供优雅的解决方案

理解装饰器的工作原理不仅有助于我们编写更好的装饰器，还能加深我们对Python函数式编程和元编程的理解，是成为高级Python开发者的重要一步

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-11-用户自定义函数

Mon, 26 Jan 2026 00:00:00 GMT

背景

polars学习系列文章，第11篇用户自定义函数，python 自定义函数如何与 polars 结合使用

该库目前已更新到 1.37.1 版本，近一年版本更新迭代的速度非常快，之前分享的前10篇文章的版本是 1.2.1

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：', sys.version.split('|')[0])
#python 版本： 3.11.11 

import polars as pl

print("polars 版本：", pl.__version__)
#polars 版本： 1.37.1

提供的 api 函数/接口/方法

map_elements ：对列中的每个值，传入函数，类似pandas中的map
map_batches ：整个列全部传入函数，类似pandas中的apply

示例数据

df = pl.DataFrame(
    {
        "keys": ["a", "a", "b", "b"],
        "values": [10, 7, 1, 23],
    }
)
print(df)
shape: (4, 2)
┌──────┬────────┐
│ keys ┆ values │
│ ---  ┆ ---    │
│ str  ┆ i64    │
╞══════╪════════╡
│ a    ┆ 10     │
│ a    ┆ 7      │
│ b    ┆ 1      │
│ b    ┆ 23     │
└──────┴────────┘

map_elements 用法

import math 

def my_log(value):
    return math.log(value)  # math.log 应用与每个值

out = df.select(pl.col("values").map_elements(my_log, return_dtype=pl.Float64))
print(out)
shape: (4, 1)
┌──────────┐
│ values   │
│ ---      │
│ f64      │
╞══════════╡
│ 2.302585 │
│ 1.94591  │
│ 0.0      │
│ 3.135494 │
└──────────┘

存在问题：

限于单个项：只用应用在单个值上面，而不能一次应用到整个列
性能开销：为每个单独的项调用函数也很慢，所有这些额外的函数调用会增加大量的开销

map_batches 用法

def diff_from_mean(series):
    total = 0
    for value in series:
        total += value
    mean = total / len(series)
    return pl.Series([value - mean for value in series])

out = df.select(pl.col("values").map_batches(diff_from_mean, return_dtype=pl.Float64))
print("== select() with UDF ==")
print(out)
== select() with UDF ==
shape: (4, 1)
┌────────┐
│ values │
│ ---    │
│ f64    │
╞════════╡
│ -0.25  │
│ -3.25  │
│ -9.25  │
│ 12.75  │
└────────┘

print("== group_by() with UDF ==")
out = df.group_by("keys").agg(
    pl.col("values").map_batches(diff_from_mean, return_dtype=pl.Float64)
)
print(out)
== group_by() with UDF ==
shape: (2, 2)
┌──────┬───────────────┐
│ keys ┆ values        │
│ ---  ┆ ---           │
│ str  ┆ list[f64]     │
╞══════╪═══════════════╡
│ a    ┆ [1.5, -1.5]   │
│ b    ┆ [-11.0, 11.0] │
└──────┴───────────────┘

提升用户自定义函数性能

numpy 通用函数

纯python实现的自定义函数一般速度都比较慢，要尽量减少代用python实现的方法，可以调用 numpy 中的实现的通用函数/算子，来加速，实际是通过调用C语言的轮子来加速

import numpy as np

out = df.select(pl.col("values").map_batches(np.log, return_dtype=pl.Float64))
print(out)

通过 Numba 提升自定义函数性能

如果 numpy 中没有可用的函数，那么自定义函数可以通过 Numba 来提速，即时编译

from numba import guvectorize, int64, float64

@guvectorize([(int64[:], float64[:])], "(n)->(n)")
def diff_from_mean_numba(arr, result):
    total = 0
    for value in arr:
        total += value
    mean = total / len(arr)
    for i, value in enumerate(arr):
        result[i] = value - mean


out = df.select(
    pl.col("values").map_batches(diff_from_mean_numba, return_dtype=pl.Float64)
)
print("== select() with UDF ==")
print(out)

out = df.group_by("keys").agg(
    pl.col("values").map_batches(diff_from_mean_numba, return_dtype=pl.Float64)
)
print("== group_by() with UDF ==")
print(out)

注意事项

加速时，数据缺失是不行的，在利用numba装饰器@guvectorize加速时，要么填充缺失值，要么删除缺失值，否则polars会报错

组合多列

@guvectorize([(int64[:], int64[:], float64[:])], "(n),(n)->(n)")
def add(arr, arr2, result):
    for i in range(len(arr)):
        result[i] = arr[i] + arr2[i]


df3 = pl.DataFrame({"values_1": [1, 2, 3], "values_2": [10, 20, 30]})

out = df3.select(
    pl.struct(["values_1", "values_2"])
    .map_batches(
        lambda combined: add(
            combined.struct.field("values_1"), combined.struct.field("values_2")
        ),
        return_dtype=pl.Float64,
    )
    .alias("add_columns")
)
print(out)

流式计算

可以使用 map_batches 的 is_elementwise=True 参数将结果流式传输到函数中

设置流式计算，需要确保是针对每个值进行计算，更节省内存

返回数据类型

返回数据类型是自动推断的，第一个非空值类型，作为结果类型

python 与 polars 数据类型映射：

int -> Int64
float -> Float64
bool -> Boolean
str -> String
list[tp] -> List[tp]
dict[str, [tp]] -> struct
any -> object 尽量禁止这种情况

可以将 return_dtype 参数传递给 map_batches

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 利用 uv “一键” 快速部署服务

Wed, 14 Jan 2026 00:00:00 GMT

背景

随着Python在Web开发、数据科学等领域的广泛应用，项目依赖管理与环境部署的效率直接影响着开发体验。传统的Python项目往往需要结合 virtualenv、pip 乃至 pipenv/poetry 等多种工具进行环境隔离、依赖安装与版本管理，步骤繁琐且容易因环境不一致导致运行问题

最近以来，一个名为 uv 的现代化、高性能 Python 包管理工具由 Astral 团队推出，它集成了虚拟环境管理、依赖解析与安装、项目初始化等核心功能，并以其极快的速度和简洁的命令受到开发者关注。uv 旨在简化 Python 项目的搭建与协作流程，通过一行命令即可完成从零开始的环境构建与依赖同步，大大提升了项目初始化与部署的效率

本文将基于一个实际的 FastAPI 项目案例，演示如何利用 uv 快速拉取现有项目、一键部署完整运行环境

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

拉取项目

这里以小编创建好的一个测试项目为案例进行操作，页面比较简单 github地址：https://github.com/DataShare-duo/uv_project

在本地终端或者git bash上执行：

git clone git@github.com:DataShare-duo/uv_project.git

uv 部署环境

前提：github上拉取的项目，必须是基于 uv 构建的

部署服务：

cd ./uv_project
uv sync 
uv run main.py

在浏览器打开 http://0.0.0.0:8000 即可访问后端的服务，是不是很简单，可见 uv 工具是多么强大，通过一个命令 uv sync 构建好了项目的运行虚拟环境，即可启动服务，以往构建环境是多么的痛苦

本地基于 uv 项目构建

以上的测试项目在本地通过 uv 构建的过程：

uv init uv_project --python 3.11
cd uv_project 
uv add fastapi
uv add uvicorn

该项目的前、后端代码，均是利用 DeepSeek 生成，并调试运行成功

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

《Python-编程从新手到高手》知识点

Tue, 23 Dec 2025 00:00:00 GMT

背景

最近小编利用业余时间充电，细读了《Python 编程从新手到高手》这本书的部分章节，作者：【美】贾森·C. 麦克唐纳，其中确实藏了不少干货！一些之前未曾涉猎的知识点，这次也被一一解锁。整理出来部分内容，分享给大家一起学习交流，共同进步呀～ 📚✨

该书中文版的翻译还是差点意思，读起来不是很通顺

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

Python中的变量：名称和值

原文中关于变量的描述：Python 用name（名称）和 value（值）来代替variable（变量）

一个name指向一个value或object（对象），就像你的名字指向你一样。可能有多个name指向同一个value，就像你可能有一个名字和一个昵称
一个value是内存中一个特定的数据实例
“变量”这个术语指代这两者的组合：一个name指向一个value
名称有作用域，它们随着函数的出现而出现，随着函数的消失而消失，但是它们没有类型
值有类型，但是没有作用域
名称被绑定到值，而这些值存在于内存中，且有一些引用指向它们。你可以把一个名称绑定到任何你想要的值上，但是你只能对特定的值执行一些有限的操作

作者强调：虽然Python是一种动态类型的语言，但是Python仍然是一种强类型的语言。名称可以随意绑定到不同类型的值上面，但是任何值都是有类型的

类属性与类方法

类属性属于类本身，而不属于某个实例。实际上，这意味着所有相关的类实例“共享”类属性。即使没有任何实例，类属性也依然存在
类方法属于类，而不属于类的某个实例

@classmethod
def inform(cls, codeword):
    cls._codeword = codeword

以上代码在类方法上使用了@classmethod装饰器。类方法将类作为其第一个参数接收，因此第一个参数被命名为cls。该inform()类方法既可以直接在SecretAgent类上调用，也可以在任何SecretAgent实例（如fox）上调用。inform()对类属性_codeword所做的更改会出现在类本身及其所有实例上

流

要想处理任何数据文件，你需要获得一个流（又称文件对象或类文件对象），其提供读取和写入内存中的特定文件的方法。一般存在两种流：

二进制流是所有流的基础，用来处理二进制数据（0和1）
文本流则处理二进制文本的编码和解码

print 刷新

指定参数：print('.', end='', flush=True)，大家一般使用的方法
全局的方法：如果需要所有的print()调用默认每次都刷新，可以在非缓冲模式下运行Python，只需要在调用程序时将-u选项传递给Python解释器即可，如python3 -u test.py

并发与并行

并发（concurrency）是编程中的多任务处理：在多个任务之间快速分配程序的注意力
并行（parallelism），并行是指多个任务同时发生
有两种方法可以在Python中实现并发：线程、异步

重点是记住这2个英文单词，比如在hive sql中，任务在集群中运行，可以启动并行，set hive.exec.parallel=true;，中文翻译有时会忽略两者差异

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 函数参数类型与使用规则详解

Wed, 03 Dec 2025 00:00:00 GMT

背景

Python以其灵活性著称，这种特性在函数参数设计中尤为明显。本文将依据语言规范，系统阐述Python函数所支持的全部参数类型及其应用

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

完整函数参数示例1

def func(pos_only=None, /, pos_kw=None, *, kw_only=None):

仅位置参数 (Positional-only) ： / 前面的参数标识：使用 / 符号分隔特点：只能通过位置传递，不能使用参数名

def func(a, b, /, c):
    # a, b 是仅位置参数
    pass

# 正确调用
func(1, 2, 3)      # a=1, b=2, c=3
func(1, 2, c=3)    # a=1, b=2, c=3

# 错误调用
func(a=1, b=2, c=3)  # TypeError: 不能使用关键字传递a, b

位置或关键字参数 (Positional-or-keyword)： / 和 * 之间的参数位置：在 / 之后，* 之前（如果没有 / 或 *，则在所有参数中）特点：既可以通过位置传递，也可以通过关键字传递

def func(a, b, c):
    # 传统写法，所有参数都是位置或关键字参数
    pass

# 两种方式都可以
func(1, 2, 3)       # 位置传递
func(a=1, b=2, c=3) # 关键字传递
func(1, b=2, c=3)   # 混合传递

仅关键字参数 (Keyword-only)：* 后面的参数标识：使用 * 符号分隔，或者单个 * 特点：必须使用关键字传递

def func(*, a, b):
    # a, b 是仅关键字参数
    pass

# 正确调用
func(a=1, b=2)

# 错误调用
func(1, 2)  # TypeError: 必须使用关键字参数

完整函数参数示例2

def comprehensive(
    pos_only_1,          # 仅位置参数
    pos_only_2=10,       # 带默认值的仅位置参数
    /,                   # 分隔符
    pos_kw_1,            # 位置或关键字参数
    pos_kw_2=20,         # 带默认值的位置或关键字参数
    *args,               # 可变位置参数
    kw_only_1,           # 仅关键字参数
    kw_only_2=30,        # 带默认值的仅关键字参数
    **kwargs             # 可变关键字参数
):
    pass

# 调用示例
comprehensive(
    1,              # pos_only_1
    2,              # pos_only_2
    3,              # pos_kw_1
    pos_kw_2=4,     # pos_kw_2
    5, 6,           # 进入args
    kw_only_1=7,    # kw_only_1
    kw_only_2=8,    # kw_only_2
    extra1=9,       # 进入kwargs
    extra2=10       # 进入kwargs
)

可变位置参数：*args

def func(a, *args, b=10):
    # args收集所有额外的位置参数
    pass

func(1, 2, 3, 4)  # a=1, args=(2,3,4), b=10

可变关键字参数： **kwargs

def func(a, **kwargs):
    # kwargs收集所有额外的关键字参数
    pass

func(1, x=2, y=3)  # a=1, kwargs={'x':2, 'y':3}

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 3.14 无GIL解释器性能测试：释放多核CPU的并行潜力

Tue, 28 Oct 2025 00:00:00 GMT

背景

Python 3.14 自2025年10月7日发布以来，已在技术社区中积累了丰富的实践与评测资料。目前国内的相关文章大多译自国外大神的博客文章，内容都很“高大上”，但在普遍适用性方面尚缺乏贴近实际的基础案例。为此，本文旨在提供一个通用的实践示例，作为后续深入研究和学习的baseline

名词解释

自由线程、无GIL与英文术语 Free-threaded 同义，均指代同一项核心语言特性，即代码在执行时不再受全局解释器锁（GIL）的约束

小编环境

#Win10 系统  安装uv 
pip install uv 

uv -V  
#uv 0.9.0 (39b688653 2025-10-07)

python -VV
#Python 3.14.0 free-threading build (main, Oct  7 2025, 15:34:02) [MSC v.1944 64 bit (AMD64)]

测试结果图

安装python3.14无GIL解释器

目前，Python官方的标准构建版本仍默认包含全局解释器锁（GIL）。若需使用无GIL的解释器，开发者需从源代码自行构建，或选用由社区提供的预编译版本。值得注意的是，工具 uv 现已提供预编译的无GIL解释器，支持用户直接安装使用。

mkdir 314t && cd 314t  #创建目录

uv init  #初始化项目
uv python list #查看所有可用的python版本
uv python install cpython-3.14.0+freethreaded-windows-x86_64-none  #安装无GIL版本
uv python pin 3.14t #切换项目解释器

测试代码

#test.py
import time
import threading
import queue

N = 3_0000_0000  #模拟任务量


def cpu_bound_task(n, thread_id, q):
   count = 0
   for i in range(n):
       count += i * i
   q.put(count)


def run_with_threads(num_threads):
   threads = []
   start = time.time()
   q = queue.Queue()
   for i in range(num_threads):
       t = threading.Thread(
           target=cpu_bound_task,
           args=(N // num_threads, i, q)  #每个线程计算 1/n
       )

       threads.append(t)
       t.start()
       
   for t in threads:
       t.join()
   end = time.time()
   print(f"Total time taken with {num_threads} threads: {end - start:.2f} seconds")
   
   
if __name__ == "__main__":
   for num in [1, 2, 4, 8, 16, 32]:
       run_with_threads(num)

运行测试代码： 小编电脑是物理4核，启动4个线程时，CPU利用率达到100%

uv run test.py
#Total time taken with 1 threads: 27.00 seconds
#Total time taken with 2 threads: 15.08 seconds
#Total time taken with 4 threads: 9.39 seconds
#Total time taken with 8 threads: 8.72 seconds
#Total time taken with 16 threads: 9.74 seconds
#Total time taken with 32 threads: 9.55 seconds

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 标准库之pathlib（二），路径操作

Wed, 15 Oct 2025 00:00:00 GMT

背景

小编之前写过一篇介绍 pathlib 标准库的文章，最近在做项目时，又发现其有一个更好用的功能，分享给大家，供大家参考学习

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

创建目录方法：Path.mkdir()

pathlib.Path.mkdir() 方法是 Python 中创建目录的核心方法，提供了灵活且安全的目录创建功能

方法签名：

Path.mkdir(mode=0o777, parents=False, exist_ok=False)

参数详解：

1. mode (可选)

作用: 设置目录权限（Unix/Linux/Mac 系统有效）
默认值: 0o777 (八进制，表示最大权限)
注意: 在 Windows 上此参数被忽略

常用权限值:

from pathlib import Path

# 创建用户可读/写/执行，组和其他用户只读/执行的目录
Path("my_dir").mkdir(mode=0o755)  # drwxr-xr-x

# 创建只有用户可读/写/执行的目录  
Path("private_dir").mkdir(mode=0o700)  # drwx------

2. parents (可选)

作用: 是否自动创建父目录
默认值: False
当 False 时: 父目录必须存在，否则抛出 FileNotFoundError
当 True 时: 自动创建所有不存在的父目录

3. exist_ok (可选)

作用: 目录已存在时的处理方式
默认值: False
当 False 时: 目录已存在会抛出 FileExistsError
当 True 时: 目录已存在不会报错

基础用法示例

示例 1: 创建单级目录

from pathlib import Path

# 在当前目录下创建新文件夹
Path("new_folder").mkdir()

# 创建指定路径的目录
Path("/tmp/example").mkdir()

示例 2: 创建多级目录（使用 `parents=True`）

from pathlib import Path

# 传统方式 - 需要逐级检查创建
# 这里演示只判断父目录是否存在
path = Path("a/b/c/d/e")
if not path.parent.exists():
    path.parent.mkdir()
path.mkdir()

# 简化方式 - 一次性创建所有层级
Path("a/b/c/d/e").mkdir(parents=True)

示例 3: 安全创建目录（使用 `exist_ok=True`）

from pathlib import Path

# 安全创建 - 目录存在也不报错
Path("my_project").mkdir(exist_ok=True)

# 等同于检查是否存在再创建
path = Path("my_project")
if not path.exists():
    path.mkdir()

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 单实例模式详解

Fri, 22 Aug 2025 00:00:00 GMT

背景

你是否听说过 Python 中的 单实例模式（Singleton Pattern）？，小编之前在阅读别人代码的时候曾经遇到过，一直不知道那段代码什么含义，后来在搜索资料时，才知道那段代码的含义是创建单实例，也正是从那之后，才知道这个名词 “单实例”，是 Python 中的一种设计模式，用大白话说就是类的实例对象在内存中只有一个

单实例模式代码

class Singleton:
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

借助大模型进行详细解释

首次创建实例对象时，类的属性 _instance = None，然后程序会进入 if 条件进行执行，重点语句：

cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
# cls._instance = super().__new__(cls, *args, **kwargs)

1. super(Singleton, cls) 的作用

super函数：用于获取父类（基类）的方法，继承父类，进行父类初始化的用法
参数含义：
- Singleton：当前类
- cls：当前类的引用（在类方法中，cls代表类本身）

这种写法明确指定了从Singleton类开始，在MRO(Method Resolution Order)中查找父类。在Python 3中可以简化为super()，但这种写法更清晰地展示了继承关系

2. .__new__(cls, *args, **kwargs)

调用父类的__new__方法：这是实际创建对象实例的关键步骤

super(Singleton, cls).__new__(cls) → 实际调用object.__new__(Singleton)

在 CPython（Python 的官方实现）中，object.__new__ 是用 C 语言实现的底层函数。它的核心工作是：

内存分配：为新对象分配适当的内存空间
对象初始化：设置对象的基本结构
返回原始对象：返回一个"空"的、未初始化的对象实例

object.__new__ 是底层实现，它不会触发 Python 层面的 __new__ 方法调用 当 object.__new__ 执行时：

它直接操作内存分配，不经过 Python 的方法查找机制
它是解释器内置的 C 函数，不是 Python 函数
它的工作就是创建原始对象，不会检查或调用任何 __new__ 方法

object.__new__(Singleton) 的工作原理：

内存分配：为 Singleton 实例分配适当大小的内存
对象初始化：设置基本对象头（类型指针、引用计数等）
返回原始对象：返回一个"空"的、未初始化的对象实例

3. 返回赋值 cls._instance= 经过第2步之后，会将原始对象赋值给 cls._instance，其实是类在内存中的地址/指针，这样类的属性不再为None，后续如果再次创建实例时，直接返回第一次创建好的实例对象

单例模式的核心优点

节省内存资源：在内存中只有一个对象，避免了重复创建实例带来的内存浪费
减少系统开销：单例可长驻内存，避免频繁的创建和销毁对象，减少系统开销
全局访问点：提供一个全局访问点，允许在应用程序中轻松访问该唯一实例
数据同步控制：全局只有一个接入点，可以更好地进行数据同步控制，避免多重占用

单例模式的实际应用场景

日志记录器：应用程序通常只需要一个日志记录器实例，避免多个日志文件冲突
数据库连接池：数据库连接是稀缺资源，使用单例模式可以统一管理连接，避免资源浪费
配置管理：应用程序的全局配置通常只需要一个实例，保证配置的一致性，比如大模型在内存/GPU中只初始化一次，来处理所有的用户请求
缓存系统：全局缓存需要统一管理，避免多个缓存实例导致数据不一致

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python collections详解：解锁高效数据结构

Tue, 12 Aug 2025 00:00:00 GMT

背景

虽然 Python 中已提供了列表、字典等非常灵活的数据结构，但是 collections 模块提供了高性能的容器数据类型，能大幅优化代码效率和可读性，本文将深入解析该模块中的六大核心工具，助你写出更优雅的Python代码，避免你重复造轮子

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

namedtuple：命名元组

传统元组通过索引访问元素，代码可读性差：

point = (2, 5)
print(f"X: {point[0]}, Y: {point[1]}")  # 可读性低

namedtuple 赋予元组字段名

from collections import namedtuple

# 创建具名元组类型
Point = namedtuple('Point', ['x', 'y'])
p = Point(2, 5)

print(p.x, p.y)  # 直观访问
print(p._asdict()) # 转为字典：{'x': 2, 'y': 5}

✅ 适用场景：数据库查询结果、坐标点等轻量级数据结构

deque：高效双端队列

列表(list)在头部插入/删除效率为 O(n)，deque 在两端操作均为 O(1)

from collections import deque

d = deque([1, 2, 3])
d.appendleft(0)  # 左侧添加 → deque([0, 1, 2, 3])
d.extend([4, 5]) # 右侧扩展 → [0,1,2,3,4,5]
d.rotate(2)      # 向右旋转 → [4,5,0,1,2,3]

🔥 性能对比：千万元素头部插入

list.insert(0, x)：耗时2.1秒

deque.appendleft(x)：耗时0.02秒

Counter：元素统计利器

快速统计可迭代对象中元素频率

from collections import Counter

text = "python collections is powerful"
word_count = Counter(text.split())

print(word_count.most_common(2))
# 输出：[('python', 1), ('collections', 1)]

# 数学运算
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)  # Counter({'a': 4, 'b': 3})

💡 进阶技巧：elements()方法生成迭代器，subtract()实现减法操作

defaultdict：智能字典

避免KeyError异常，自动初始化默认值

from collections import defaultdict

# 值为列表的字典
dd = defaultdict(list)
dd['fruits'].append('apple')  # 无需初始化
print(dd['animal'])  # 访问不存在的key，返回空列表 []

# 值为计数的字典
count_dict = defaultdict(int)
for char in "abracadabra":
    count_dict[char] += 1

支持任意可调用对象：defaultdict(lambda: 'N/A')

ChainMap：字典聚合器

合并多个字典而不创建新对象

from collections import ChainMap

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

chain = ChainMap(dict1, dict2)
print(chain['b'])  # 输出2（dict1优先）
print(chain['c'])  # 输出4

# 动态添加字典
chain = chain.new_child({'d': 5})

🌟 特点：查找顺序可定制，原始字典修改实时同步

OrderedDict：有序字典

虽然Python3.7+的dict已有序，但OrderedDict提供额外功能

from collections import OrderedDict

od = OrderedDict()
od['z'] = 1
od['a'] = 2
print(list(od.keys()))  # 保持插入顺序：['z', 'a']

# 特殊方法
od.move_to_end('z')  # 移动键到末尾 ，OrderedDict([('a', 2), ('z', 1)])
od.popitem(last=False)  # FIFO删除，删除 ('a', 2)

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 函数参数：列表作为默认值，一个隐藏的陷阱！

Tue, 05 Aug 2025 00:00:00 GMT

背景

在Python编程中，函数参数的设计直接影响代码的健壮性和可预测性。**一个需要警惕的实践是：避免将可变对象（尤其是列表）作为函数参数的默认值。**这样做可能导致极其隐蔽且令人困惑的bug

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

现象：一个诡异的“记忆”功能

想象你设计了一个函数，用来记录新添加的学生姓名到某个班级列表。如果列表为空，则创建一个新列表：

def add_student(name, student_list=[]):
    student_list.append(name)
    return student_list

# 第一次调用：添加Alice
class1 = add_student("Alice")
print(class1)  # 输出: ['Alice'] 

# 第二次调用：添加Bob
class2 = add_student("Bob")
print(class2)  # 输出: ['Alice', 'Bob']

问题来了： 第二次调用add_student("Bob")时，并没有传递student_list参数，期望的是生成一个只包含**"Bob"的新列表。但结果却包含了第一次添加的"Alice"**！这个函数似乎“记住了”之前的调用

原因揭秘：列表是引用类型

要理解这个问题的本质，必须明白Python中变量的工作方式：

列表是引用类型 在Python中，变量存储的是对象的引用（内存地址），而不是对象本身。当你将一个列表赋值给变量时，实际上是在创建一个指向列表对象的引用。
默认参数的创建时机 当Python解释器遇到函数定义时，它会立即创建默认参数对象。对于列表这样的可变对象，这意味着只有一个列表对象被创建，并且这个对象会持续存在于整个程序的生命周期中。
函数调用时的陷阱 当你多次调用函数而不提供参数时，Python不会创建新的列表，而是重复使用同一个默认列表对象。因为列表是可变的，每次对它的修改都会永久改变这个共享对象。
引用传递的后果 由于函数操作的是指向同一个列表对象的引用，所有使用默认参数的调用实际上都在操作同一个物理列表。这就是为什么数据会"神奇地"在函数调用之间保留下来

解决方案：使用不可变默认参数

正确的做法是使用 None 作为哨兵值

def add_item(item, items=None):
    if items is None:
        items = []  # 每次调用都创建新列表
    items.append(item)
    return items

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 项目管理新思路：用 uv Workspace 共享虚拟环境，省时省空间！

Tue, 29 Jul 2025 00:00:00 GMT

背景

上手 uv 一段时间后，真心觉得这款工具让 Python 项目管理变得省心不少！它不仅操作便捷，安装第三方包的速度更是快得飞起。

不过，在使用过程中也发现了一个小痛点：uv 默认会为每个项目创建独立的虚拟环境。这意味着，如果你同时开发多个项目，即使它们依赖相同的第三方包（比如常用的 requests、pandas），这些包也需要在每个项目的虚拟环境中重复安装。久而久之，宝贵的磁盘空间就这样被悄悄占用了不少。

难道只能忍受这种“甜蜜的负担”吗？当然不是！仔细翻阅 uv 的文档后发现，它其实贴心地提供了工作空间（Workspace）功能！通过工作空间，你可以让多个项目共享同一个虚拟环境。这样一来，公共依赖包只需安装一次，所有关联项目都能顺畅使用，大幅减少了重复安装带来的空间浪费，管理效率再上一个台阶！

在尝试获取 uv 工作空间（Workspace） 功能的相关信息时，小编注意到 DeepSeek 模型提供的回答有时存在不准确或偏离主题的情况。

这表明，uv 这一相对较新的功能细节，可能尚未被充分纳入 DeepSeek 当前模型版本的训练数据。这一现象也提醒我们，即使是强大的 AI 模型，其知识覆盖和能力也存在一定的边界与时效性局限

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

uv self version
# uv 0.8.2 (21fadbcc1 2025-07-22)

工作空间示例

创建根项目，并添加一个三方包 pandas 在根项目的文件夹里面生成一个虚拟环境 .venv ，pandas被安装在该文件夹内

uv init workspace_project  -p 3.11
cd workspace_project
uv add pandas
uv tree

workspace-project v0.1.0
└── pandas v2.3.1
    ├── numpy v2.3.1
    ├── python-dateutil v2.9.0.post0
    │   └── six v1.17.0
    ├── pytz v2025.2
    └── tzdata v2025.2

创建子项目1，并添加一个三方包 fastapi 在子项目中添加的包，会被安装到根项目的虚拟环境.venv中

pwd  # D:\桌面\Python\uv\workspace_project
uv init sub_project1  # 创建子项目1
cd sub_project1  
uv add fastapi
uv tree

workspace-project v0.1.0
└── pandas v2.3.1
    ├── numpy v2.3.1
    ├── python-dateutil v2.9.0.post0
    │   └── six v1.17.0
    ├── pytz v2025.2
    └── tzdata v2025.2
sub-project1 v0.1.0
└── fastapi v0.116.1
    ├── pydantic v2.11.7
    │   ├── annotated-types v0.7.0
    │   ├── pydantic-core v2.33.2
    │   │   └── typing-extensions v4.14.1
    │   ├── typing-extensions v4.14.1
    │   └── typing-inspection v0.4.1
    │       └── typing-extensions v4.14.1
    ├── starlette v0.47.2
    │   ├── anyio v4.9.0
    │   │   ├── idna v3.10
    │   │   ├── sniffio v1.3.1
    │   │   └── typing-extensions v4.14.1
    │   └── typing-extensions v4.14.1
    └── typing-extensions v4.14.1

创建子项目2，并添加一个三方包 requests

pwd  # D:\桌面\Python\uv\workspace_project
uv init sub_project2  # 创建子项目1
cd sub_project2  
uv add requests
uv tree

workspace-project v0.1.0
└── pandas v2.3.1
    ├── numpy v2.3.1
    ├── python-dateutil v2.9.0.post0
    │   └── six v1.17.0
    ├── pytz v2025.2
    └── tzdata v2025.2
sub-project2 v0.1.0
└── requests v2.32.4
    ├── certifi v2025.7.14
    ├── charset-normalizer v3.4.2
    ├── idna v3.10
    └── urllib3 v2.5.0
sub-project1 v0.1.0
└── fastapi v0.116.1
    ├── pydantic v2.11.7
    │   ├── annotated-types v0.7.0
    │   ├── pydantic-core v2.33.2
    │   │   └── typing-extensions v4.14.1
    │   ├── typing-extensions v4.14.1
    │   └── typing-inspection v0.4.1
    │       └── typing-extensions v4.14.1
    ├── starlette v0.47.2
    │   ├── anyio v4.9.0
    │   │   ├── idna v3.10
    │   │   ├── sniffio v1.3.1
    │   │   └── typing-extensions v4.14.1
    │   └── typing-extensions v4.14.1
    └── typing-extensions v4.14.1

所有的三方包都安装在根项目的虚拟环境内，path\workspace_project\.venv\Lib\site-packages，这样公共依赖包只需安装一次

以上的操作，其实是 uv 自动在根项目的配置文件 pyproject.toml 中，增加了如下配置，这样 uv 才识别所有项目同属于一个工作空间

[tool.uv.workspace]
members = [
    "sub_project1",
    "sub_project2",
]

在子项目2中使用同工作空间其它项目安装的包

import pandas as pd 
import fastapi

def main():
    print("Hello from sub-project2!")


if __name__ == "__main__":
    main()
    print('pandas版本：',pd.__version__)
    print('fastapi版本：',fastapi.__version__)

运行：

pwd  # D:\桌面\Python\uv\workspace_project\sub_project2
uv run .\main.py
# Hello from sub-project2!
# pandas版本： 2.3.1
# fastapi版本： 0.116.1

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 2个好用的装饰器函数

Tue, 22 Jul 2025 00:00:00 GMT

背景

装饰器：Python开发者的效率利器！ 🛠️

在Python的世界里，装饰器绝对是一把强大的“瑞士军刀”。它能帮我们优雅地封装通用逻辑，大幅减少重复代码，真正实现事半功倍的开发效率。

如果你是第一次接触装饰器这个概念，强烈建议先找些基础资料了解一下它的核心思想和工作原理（别担心，小编当初也是一头雾水，看别人的代码完全摸不着头脑）。打好基础再往下看，理解起来会顺畅得多，相信小编！

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

计算耗时

想知道函数执行耗时？一个装饰器轻松搞定！⏱️

还在手动写 time.time() 包裹你的函数来计算耗时吗？太麻烦啦！只需几行代码定义一个计时装饰器，轻轻松松给任何函数“戴上”，就能自动获取精准的执行时间

def time_it(func):
    @wraps(func)  # 保留原始函数的元数据
    def wrapper(*args, **kwargs):
        print("开始执行---->")
        start_time=datetime.datetime.now()
        result = func(*args, **kwargs)
        end_time=datetime.datetime.now()
        print(f"结束执行，消耗时长为：{end_time - start_time}")
        return result
    return wrapper

重试机制

在程序中调用外部API、访问数据库或进行网络请求时，网络环境的不稳定性往往是导致程序“意外扑街”的头号元凶！面对这种不可控因素，与其祈祷网络永远畅通，不如主动出击——引入重试机制，来增加程序的健壮性

def retry(func=None,*,times=3):
    if func is None:
        return partial(retry,times=times)
    
    @wraps(func)
    def wrapper(*args,**kwargs):
        for attempt in range(1,times+1):
            try:
                return func(*args,**kwargs)
            except Exception as exc:
                print(f"函数 {func.__name__} 进行第 {attempt} 次尝试，遇到错误：{exc}")
                sleep(SLEEP_TIME * attempt)
        print(f"所有尝试均失败！！！")
        return None
    
    return wrapper

完整代码

from time import sleep
import datetime
from functools import wraps,partial  # 导入 wraps 装饰器

SLEEP_TIME=1

def time_it(func):
    @wraps(func)  # 保留原始函数的元数据
    def wrapper(*args, **kwargs):
        print("开始执行---->")
        start_time=datetime.datetime.now()
        result = func(*args, **kwargs)
        end_time=datetime.datetime.now()
        print(f"结束执行，消耗时长为：{end_time - start_time}")
        return result
    return wrapper


def retry(func=None,*,times=3):
    if func is None:
        return partial(retry,times=times)
    
    @wraps(func)
    def wrapper(*args,**kwargs):
        for attempt in range(1,times+1):
            try:
                return func(*args,**kwargs)
            except Exception as exc:
                print(f"函数 {func.__name__} 进行第 {attempt} 次尝试，遇到错误：{exc}")
                sleep(SLEEP_TIME * attempt)
        print(f"所有尝试均失败！！！")
        return None
    
    return wrapper
    

if __name__=='__main__':
    
    @retry
    @time_it
    def cal(x):
        total=0
        for i in range(x):
            total += i
            
        return total 
    
    print(cal(100000000))
    print(cal('100000'))

运行测试结果

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 迈向强类型化的优雅转变

Mon, 16 Jun 2025 00:00:00 GMT

背景

Python 不再是你记忆中的“弱类型”语言了！随着类型注释的普及和高版本Python的演进，它正悄然蜕变为一门兼具灵活性与严谨性的现代语言

为什么使用类型注释？

1. 提升可读性 类型注释是代码的“自文档化”工具，明确参数和返回值的类型，让代码意图一目了然

def process_data(data: list[int], threshold: float) -> list[float]:
    return [x * threshold for x in data if x > 0]

2. 错误早捕获 结合静态检查工具（如 mypy），在运行前发现类型错误，告别隐藏的 TypeError！

pip install mypy  
mypy your_script.py  # 静态检查

3. IDE智能支持 VS Code/PyCharm 等工具通过类型注释提供精准的代码补全和错误提示，开发效率翻倍

Python 已悄然“强类型化”

动态类型 ≠ 弱类型 Python 仍是动态类型语言，但类型注释的引入（PEP 484）和社区实践推动它向强类型风格演进
高版本特性加持（Python 3.10+）
- 联合类型简化：int | str 替代 Union[int, str]
- 类型守卫：用 isinstance() 细化类型范围（PEP 647）
- 模式匹配：match/case 中类型推断更智能

如何开始？

1. 升级Python版本

# 推荐使用 Python 3.10 或更高版本
python --version  # 检查版本

2. 渐进式添加类型

从关键函数参数和返回值开始
无需一次性改造旧代码！

3. 常用类型示例

from typing import Optional, TypedDict

class UserProfile(TypedDict):
    name: str
    age: Optional[int]

def greet(user: UserProfile) -> None:
    print(f"Hello, {user['name']}!")

拥抱改变，代码长青

类型注释不仅是“语法糖”，更是工程实践的进化。切换到 Python 高版本，用类型注释写出更健壮、更易维护的代码，迎接 Python 的强类型新时代！

你目前使用的是Python哪个版本？欢迎留言交流

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 新晋包项目工具uv的简单尝试

Tue, 20 May 2025 00:00:00 GMT

背景

小编最近看公众号里面 uv 文章比较多，于是也尝试着用了一下，整体感觉对于开发项目人员来说很好，方便自动管理项目依赖，后期在部署时，可以根据 uv 自动构建的项目依赖来进行配置，省去各种包冲突麻烦

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.11

安装uv

自己本地已经安装了python，可以直接使用 pip 进行安装

pip install uv -i https://pypi.tuna.tsinghua.edu.cn/simple

uv --version
#uv 0.7.3 (3c413f74b 2025-05-07)

uv各命令

初始化项目

初始化项目时，可以指定python版本

uv init test1 
uv init test2 -p 3.11
uv init test3 --python 3.11

添加依赖

用于安装包并自动更新项目配置文件（pyproject.toml）和锁定文件（uv.lock）

uv add 可以理解为 uv pip install的增强版，底层同样是利用了pip进行安装，但是uv add额外增加了更新项目配置文件的功能

uv add pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

删除依赖 也会自动删除pandas依赖的其他包

uv remove pandas

显示完整依赖树

uv tree

uv python 命令

list	列出可用的Python安装版本
install	下载并安装Python版本
find	显示当前Python安装位置
pin	固定使用特定Python版本
dir	显示uv Python安装目录
uninstall	卸载Python版本

uv 升级，自己升级

uv self update

设置全局默认python版本

uv python pin --global 3.11

安装python版本

uv python install 3.13

显示已安装的 Python 版本路径

uv python dir

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 在指定文件夹安装三方库，并进行加载使用

Thu, 17 Apr 2025 00:00:00 GMT

背景

在公司内部的服务器中，安装三方库是需要经过层层审批，最后由运维人员进行安装，员工一般是没有权限去随意安装三方库，在审批之前需要进行测试验证可行性，那么这时就需要把三方库安装到自己有权限的目录中，然后再进行使用。小编这里经过亲身测试验证，分享出来供大家参考学习

指定文件夹下安装三方库

在python中安装三方库，默认使用 pip 命令进行安装，在该命令中可以通过 target 指定安装到的文件夹位置

pip3 install pyspark==2.4.3 \
    --target=/mnt/disk1/datashare/python \ 
    -i https://mirrors.aliyun.com/pypi/simple/   #指定阿里源

加载指定文件夹下安装的三方库

在安装三方库时是安装在指定文件夹下，所以需要把指定文件夹插入到 sys.path 的第1个位置，否则会加载系统自带的版本

import sys

lib_path = "/mnt/disk1/datashare/python"
sys.path.insert(0,lib_path)   #插入安装三方库的文件夹

import pyspark

print(pyspark.__version__)
#2.4.3

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Clickhouse 读取存储在hdfs的hive表数据

Mon, 17 Mar 2025 00:00:00 GMT

背景

离线数据经过 hive 处理后，生成的新数据，有时需要对接至研发侧 clikehouse，供前端用户查询使用，所以会涉及到hive数据同步至clikehouse，因为hive数据底层是存储在 hdfs ，因此只要知道hive的建表语句（元数据），再结合 clikehouse 中的特定表引擎（本质是表映射），即可实现 clikehouse 直接读取hdfs数据

小编环境

操作系统版本与 Clickhouse 版本

cat /etc/redhat-release
# CentOS Linux release 7.2.1511 (Core)

clickhouse -V
#ClickHouse local version 24.7.2.13 (official build)

hive中建表并插入测试数据

设置字段分割符为 \t

--建表语句
create table  test_bigdata.test_hdfs_ck (
uid string comment '用户id',
name string comment '姓名',
age bigint comment '年龄',
dt string comment '注册日期'
)  
row format delimited fields terminated by '\t'
stored as textfile
;

--插入数据
insert into table test_bigdata.test_hdfs_ck
values 
('uid1','张三','18','20250101'),
('uid2','john','28','20250317'),
('uid3','deepseek','10','20250315')
;

在clikehouse中创建HDFS映射表

前提：需要打通不同服务器之间的网络策略 利用 clikehouse 中的 HDFS 表引擎，指定 hdfs 的路径、hive中表的存储格式，即可创建映射表

--创建HDFS映射表
create table test.test_hdfs_ck (
uid String comment '用户id',
name String comment '姓名',
age UInt16 comment '年龄',
dt Date comment '注册日期'
)
ENGINE = HDFS('hdfs://10.20.1.1:8020/user/hive/warehouse/test_bigdata.db/test_hdfs_ck/*', 'TSV')
;

在clikehouse中创建本地表，并导入数据

用户在查询数据时，需要实时返回，有时效性要求，所以需要把hdfs的映射表数据导入本地表中

--创建本地表
create table test.test_ck (
uid String comment '用户id',
name String comment '姓名',
age UInt16 comment '年龄',
dt Date comment '注册日期'
)
ENGINE=MergeTree
PARTITION BY dt
ORDER BY uid
;

--把映射表数据导入本地表
insert into test.test_ck
select *
from test.test_hdfs_ck
;

注意事项

低版本 clickhouse 不支持创建该表类型引擎
需要有权限读取hdfs指定路径，默认是clikehouse用户
日期格式的解析，clickhouse 中默认可以直接解析 yyyy-MM-dd，但标准规范的8位数字 yyyyMMdd 在映射时，也可以自动解析

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 基于协程的端口扫描工具

Tue, 14 Jan 2025 00:00:00 GMT

背景

端口扫描技术广泛应用于网络运维、网络安全测试、以及黑客攻击服务器等领域。在网络运维中，管理员通过端口扫描来检查服务器或设备的开放端口，确保网络安全并及时发现潜在的漏洞。在网络安全测试中，端口扫描帮助识别网络中的弱点，进而制定防护措施，提升整体安全性。而在黑客攻击的情境下，攻击者通过端口扫描发现目标设备开放的服务，从而寻找攻击入口点，实施非法入侵。因此，端口扫描不仅是安全防护的一个重要工具，也常被黑客用作攻击手段。

本篇文章的目的是通过构建一个端口扫描工具，深入探讨如何在Python中利用协程进行高效的网络端口扫描。传统的端口扫描通常是串行的，效率较低，尤其在扫描大量IP时，耗时非常长。借助Python的协程特性，我们可以实现高并发的网络扫描，显著提高扫描速度，并且在处理多个任务时能够有效地节省系统资源。通过实践这一过程，读者不仅可以掌握端口扫描的基本原理，还能进一步理解如何在Python中高效地使用协程来解决实际问题。

小编环境

import sys

print('python 版本：',sys.version)
#python 版本： 3.11.11 | packaged by Anaconda, Inc. | 
#(main, Dec 11 2024, 16:34:19) [MSC v.1929 64 bit (AMD64)]

效果

直接扫描IP地址：

扫描域名：

完整代码

import asyncio
import socket
from datetime import datetime


class ScanPort:
    def __init__(self, concurrency_limit=100):
        self.ip = None
        self.concurrency_limit = concurrency_limit  # 并发限制，默认是 100

    async def scan_port(self, port, semaphore):
        try:
            # 获取信号量
            async with semaphore:
                # 创建异步 TCP 连接
                conn = asyncio.open_connection(self.ip, port)
                reader, writer = await asyncio.wait_for(conn, timeout=1)
                writer.close()
                await writer.wait_closed()
                print(f'Ip: {self.ip} Port: {port} IS OPEN')
        except (asyncio.TimeoutError, ConnectionRefusedError, OSError):
            pass  # 忽略连接超时或端口未开启的错误

    async def scan_ports(self):
        semaphore = asyncio.Semaphore(self.concurrency_limit)  # 限制最大并发数
        tasks = []

        for port in range(1, 65536):  # 要扫描的端口范围
            tasks.append(self.scan_port(port, semaphore))  # 为每个端口创建一个异步任务

        await asyncio.gather(*tasks)  # 并发执行所有任务

    def start(self):
        host = input("please input the host want to scan: ")
        self.ip = socket.gethostbyname(host)  # 获取主机的 IP 地址
        start_time = datetime.now()

        # 执行异步扫描
        asyncio.run(self.scan_ports())

        print("port scan has done, use time:", datetime.now() - start_time)

if __name__ == "__main__":
    # 运行扫描程序
    ScanPort(concurrency_limit=2000).start()  # 设置并发量限制为2000

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Clickhouse 基础使用教程

Thu, 19 Dec 2024 00:00:00 GMT

背景

小编最近在做一个数据类产品项目，每天涉及到几十亿数据的汇总计算，从不同维度、不同的关联关系进行汇总统计，刚开始时项目组使用的是hive，写好大量的业务SQL计算逻辑后（中间有一些其他程序处理脚本），每天通过定时任务来生成数据，然后把生成的数据推送到研发端的ES（Elasticsearch），研发端基于ES查询数据，给到前端来展示

但是，随着项目的不断深入，产品需求的快速迭代，之前的各种统计指标更新迭代，基于hive数据库的计算方式不能再满足当前快速迭代的场景。项目组经过调研，最终选择Clickhouse数据库，让研发来每天通过查询Clickhouse数据库，来统计生成各种统计指标，并把结果缓存至ES

项目数据架构的大概思路：

hive每日生成明细数据，把这些明细数据导入Clickhouse
在Clickhouse中生成一些中间表，供研发人员查询数据使用，方便进行各种拼接组合
研发人员每日基于明细表、中间表，计算统计指标，把结果缓存至ES

小编环境

操作系统版本与 Clickhouse 版本

cat /etc/redhat-release
# CentOS Linux release 7.2.1511 (Core)

clickhouse -V
#ClickHouse local version 24.7.2.13 (official build)

登录客户端

clickhouse-client -u xxxx --password xxxxxx -m

-u 或者 --user ：指定用户名 --password ：密码 -m 或者 --multiline ：进入客户端后，运行输入多行sql语句

建表

在Clickhouse中，数据既可以存放到单个服务器节点，也可以把数据分散存放到集群中各个节点服务器中，这个需要看数据量大小，来选择合适的表类型

创建本地表 如果数据量比较小的话，建议选择本地表，在数据查询时以提高性能，可以节省节点之间数据传输的时间，比如有几千万行数据的表，完全可以选择本地表，但是查询数据时，只能在当前服务器节点查询，其他服务器节点没有该表

下面以用户表为列，进行建表操作：

create table test.user_table (
uid String comment '用户id',
sex String comment '性别',
age UInt16 comment '年龄',
phone String comment '联系电话'
)
engine = MergeTree()
order by uid;

数据类型需要注意是大写开头，String、UInt16，表引擎类型也必须大写 MergeTree
如果没有指定主键的话，默认用 order by 指定的字段

创建分布式表 分布式表在Clickhouse中，只是一个视图，不实际存放数据，指向实际存放数据的本地表，所以在创建分布式表时，需要在各个服务器节点创建名字一模一样的本地表

--在集群中创建实际存放数据的本地表
create table test.user_event on cluster data_cluster(
uid String comment '用户id',
event String comment '事件名称',
c_time DateTime comment '点击时间',
dt Date comment '日期'
)
engine = MergeTree()
partition by dt 
order by uid;

--创建分布式表
create table test.user_event_distributed (
uid String comment '用户id',
event String comment '事件名称',
c_time DateTime comment '点击时间',
dt Date comment '日期'
)
engine = Distributed('data_cluster', 'test', 'user_event', rand())
;

分布式表需要选择 Distributed 表引擎，其中第1个参数：集群名称第2个参数：数据库名第3个参数：数据表名第3个参数：分片key，数据被到不同服务器依据的字段，相同的值会被分配到同一台服务器

如果在创建分布式表 test.user_event_distributed 时没有指定 on cluster data_cluster，那么创建是本地表，后续的查询只能在建表的那个节点服务器查询数据，这里小编就创建的是一个本地表

查询

Clickhouse 的sql 查询语句和hive的比较类似，使用起来基本没啥差距，只有极个别的函数不支持，下面小编列举一下自己在使用时，遇到的个别函数：

没有 nvl 函数，需要用 coalesce 代替
支持窗口函数，row_number 等
没有 concat_ws，需要用 arrayStringConcat 代替
没有 collect_list，需要用 groupArray 代替
一个好用的函数，arrayZip，类似python中的zip
没有 split 函数，需要用 splitByString 代替
arrayMap、arraySum、arraySlice 等函数很好用，性能高

表变更

删除特定分区

alter table test.user_event on cluster data_cluster drop partition '2024-11-30';
alter table test.user_event on cluster data_cluster delete where dt > '2024-11-15';
alter table test.user_event on cluster data_cluster delete where dt='2024-11-30';

删除满足特定条件数据

alter table test.user_event on cluster data_cluster delete where user_id='u00001';

自定义函数

不推荐使用外部语言编写自定义函数，例如：java、python 等，推荐使用自有的函数，逐步组合实现自定义函数，性能高

一个样例：

--分割字符串并把类型转换为整数
create function x_split as (x) ->
(
    arrayMap(
            y -> toUInt32(y), 
            splitByString(',', x)
        )
);

历史相关文章

Clickhouse中创建生成日期序列自定义函数

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Clickhouse中创建生成日期序列自定义函数

Mon, 09 Dec 2024 00:00:00 GMT

背景

Clickhouse 数据库最近几年在大数据领域应用越来越广，因其卓越的性能，外加支持海量数据存储与处理，国内很多大厂都有在使用。其底层使用C++语言编写，小编在使用时，感觉可以极限压榨CPU性能，计算速度远超 Hive，应用在数据产品领域，基本没啥问题

存储的数据量，可以与Hadoop生态持平
计算性能，可以与Mysql持平

小编环境

操作系统版本与Clickhouse版本

cat /etc/redhat-release
# CentOS Linux release 7.2.1511 (Core)

clickhouse -V
#ClickHouse local version 24.7.2.13 (official build)

效果展示

提供开始日期、结束日期，生成一个日期序列，返回的是一个数组

select generateSeries_dt('2024-12-01','2024-12-07') as dts;
--['2024-12-01','2024-12-02','2024-12-03','2024-12-04',
--'2024-12-05','2024-12-06','2024-12-07']

生成日期序列自定义函数

因Clickhouse 是用C++语言编写，如果想扩展自定义函数，需要用C++来实现或借助sql方式实现，如果想使用其他语言，则只能进行桥接（把数据输出至系统，在系统中调用其他语言处理数据，然后把系统中输出的结果，拿回到clickhouse）。这里小编借助sql 方式来实现，感觉实现起来和编写python很像

利用Chatgpt的帮助，可以一步一步完成所需要的函数功能

create function generateSeries_dt as (start_dt,end_dt) -> 
(
    arrayMap(
        x -> toDate(start_dt) + x, 
        range(toUInt32(toDate(end_dt) - toDate(start_dt)) + 1)
    )
);

将字符串 start_dt 和 end_dt 转换为 Date 类型：toDate(start_dt) 和 toDate(end_dt)
计算日期之间的差值：toDate(end_dt) - toDate(start_dt)，结果是天数
使用 range 函数生成从 0 到差值的整数序列：range(toUInt32(...) + 1)
使用 arrayMap 遍历序列，将每个整数加到起始日期上，生成完整的日期序列

通过上面的详细解释，感觉是不是和python很像，经过测试，其性能大概是java编写的自定义函数性能100倍

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

hadoop 常用命令总结

Fri, 27 Sep 2024 00:00:00 GMT

背景

在本地记事本记得太多了，有的命令使用频次很低，时间长了容易忘记，分享出来后续使用时查找

常用命令

列出数据库下的所有表

hadoop fs -ls /user/hive/warehouse/test.db

统计数据库占用磁盘的总大小

hadoop fs -du -s -h /user/hive/warehouse/test.db

查看数据表中的数据

hadoop fs -cat /user/hive/warehouse/test.db/test/00000_0 | head

设置副本数 Hadoop默认是3个副本，replication factor 副本因子

hadoop fs -setrep -R 1 /user/hive/warehouse/test.db/test

创建文件夹

hadoop fs -mkdir /user/datashare

修改文件权限

hadoop fs -chmod 700 /user/datashare
hadoop fs -chmod -R 700 /user/datashare   #递归进行，针对子文件夹

检查HDFS中的文件是否存在

hadoop fs -test -e /user/hive/warehouse/test.db/test/0*

统计文件个数

hadoop fs -ls -h /user/hive/warehouse/test.db/test/dt=202310 | wc -l
hadoop fs -count /user/hive/warehouse/test.db/test/dt=202310

统计多个文件夹的总占用大小

hadoop fs -du -s  /user/hive/warehouse/test.db/test/dt=202310*  |   awk '{print $1}' | awk '{sum+=$1}END{print sum/1024**3 " G"}'

统计每个文件夹的单独大小

hadoop fs -du -s  /user/hive/warehouse/test.db/test/dt=202310*  |   awk '{print $1/1024**3 " G"}'

跨集群访问

hadoop fs -ls hdfs://10.20.1.100:8100/

查看hadoop 版本

hadoop version

查看数据缺失的块

hadoop fsck /user/hive/warehouse/test.db/test

复制分区至新表

1. CREATE TABLE new_table LIKE old_table;
2. 使用hadoop fs -cp 命令，把old_table对应的HDFS目录的文件夹全部拷贝到new_table对应的HDFS目录下；
3. 使用MSCK REPAIR TABLE new_table;修复新表的分区元数据；

查看数据库里面各数据表的大小，并进行排序

hadoop fs -du -s /user/hive/warehouse/test.db/* | sort -n | numfmt --to=iec --field=1

numfmt --to=iec --field=1 的作用是仅将第一列（大小）转换为人类可读的格式，而不改变第二列（路径）的内容。 --field=1 让 numfmt 只处理第一列，从而避免误修改文件路径

hadoop fs -rm /user/hive/warehouse/emptydir

删除文件夹

hadoop fs -rmr /user/hadoop/dir

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Rust 是否会重写 Python 解释器与有关的库，替代 C 语言地位？

Tue, 24 Sep 2024 00:00:00 GMT

背景

近2年随着Rust语言的大力发展，一些系统与软件开始逐渐使用Rust语言来实现，并且一些大型公司也开始逐渐转向Rust

因为在学习 Polars 库时，看到该库是使用Rust实现的，小编近一年也逐渐开始学习Rust语言，了解到其中的一些思想相对其他语言来说确实比较先进，所有权概念的引入，不仅可以提升性能，而且还保证了数据安全、准确，不会有数据竞争问题的产生

小编最近在处理加解密任务时，借助Rust语言实现了一个DES加解密库，借助Rust 中的 pyo3 包，在Python 中借助 maturin 库，可以把 Rust 实现的库转换为 Python 的包，供Python调用

DES加解密，Rust实现

use pyo3::prelude::*;

use openssl::provider::Provider;
use openssl::symm::{Cipher,encrypt,decrypt};
use hex;

const KEY:&[u8; 8]=b"ABCD1234";
const IV:&[u8; 8]=b"ABCD1234";

#[pyfunction]
fn des_encrypt(data:String)-> String {
    let _provider = Provider::try_load(None, "legacy", true).unwrap();
    let cipher: Cipher = Cipher::des_cbc();

    let ciphertext = encrypt(cipher, KEY, Some(IV), data.as_bytes());
    
    hex::encode(&ciphertext.unwrap()).to_uppercase()

}

#[pyfunction]
fn des_decrypt(data:String)-> String {
    let _provider = Provider::try_load(None, "legacy", true).unwrap();
    let cipher: Cipher = Cipher::des_cbc();
    
    match hex::decode(&data) {
        Ok(bytes) => {
            // println!("Decoded: {:?}", bytes); // 输出: [104, 101, 108, 108, 111]
            // println!("{:?}", des_decrypt(&bytes));
            match decrypt(cipher, KEY, Some(IV), &bytes) {
                Ok(bytes) => {
                    // println!("Decoded: {:#?}", bytes); // 输出: [104, 101, 108, 108, 111]
                    match String::from_utf8(bytes) {
                        Ok(string) => string, // 输出: "hello"
                        Err(_) => "".to_string(),
                    }
                },
                Err(_) => "".to_string(),
            }
        },
        Err(_) => "".to_string(),
    }

}

#[pymodule]
fn des_rust(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(des_encrypt, m)?)?;
    m.add_function(wrap_pyfunction!(des_decrypt, m)?)?;
    
    Ok(())
}

然后利用 Maturin 进行打包，可以生成 Python 的库/包/轮子，小编这里生成的是 des_rust-0.1.0-cp37-abi3-win_amd64.whl

然后安装该包后，即可在Python中进行使用

Python 使用

from des_rust import des_decrypt,des_encrypt

data=des_decrypt(des_encrypt('DataShare'))

print(data)    #DataShare

通过性能测试，效率相对使用Python实现的包，性能有大幅提升

进一步思考

通过以上的案例，小编走通了从Python中调用Rust代码的流程，结合小编学习 Rust 的思考，那么Rust + Python 结合，是否会成为将来数据分析、机器学习领域的趋势？

Python 比较灵活，拿来即用，学习起来也容易，现在普及程度也很广，最重要的是能很快出成果，处在现阶段的社会，出成果很重要，有的老板恨不得第1天晚上想出了一个idea，第2天就想要成果，当然这个也不能怨老板，只能说现阶段竞争很激烈
Rust 内存安全、性能高，可以弥补Python 的不足，截止当前已经有很多Python 库是使用Rust 实现的，随着老板的想发愈发复杂，想提升数据处理性能，只能使用底层的语言实现，但也不能另起炉灶，否则前期的工作相当于白做，而且业务也需要快速迭代

Rust + Python 结合是否会成为将来数据领域的趋势呢？让我们拭目以待

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-10-时间序列类型

Mon, 05 Aug 2024 00:00:00 GMT

背景

polars学习系列文章，第10篇时间序列类型（Time series）

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 1.2.1

日期时间类型

Polars 原生支持解析时间序列数据，而且能执行一些复杂的操作

包含的日期时间类型：

Date：日期类型，例如：2014-07-08，内部表示为自1970-01-01的天数，用32位有符号整数表示
Datetime：日期时间类型，例如：2014-07-08 07:00:00
Duration：时间间隔类型
Time：时间类型

从文件加载数据时，解析时间

从csv文件加载数据时，可以指定 try_parse_dates=True，让polars去尝试解析日期时间

df = pl.read_csv("./data/apple_stock.csv", try_parse_dates=True)
print(df)
#shape: (100, 2)
┌────────────┬────────┐
│ Date       ┆ Close  │
│ ---        ┆ ---    │
│ date       ┆ f64    │
╞════════════╪════════╡
│ 1981-02-23 ┆ 24.62  │
│ 1981-05-06 ┆ 27.38  │
│ 1981-05-18 ┆ 28.0   │
│ 1981-09-25 ┆ 14.25  │
│ 1982-07-08 ┆ 11.0   │
│ …          ┆ …      │
│ 2012-05-16 ┆ 546.08 │
│ 2012-12-04 ┆ 575.85 │
│ 2013-07-05 ┆ 417.42 │
│ 2013-11-07 ┆ 512.49 │
│ 2014-02-25 ┆ 522.06 │
└────────────┴────────┘

字符串转换为日期时间类型

通过调用字符串的 str.to_date 方法，需要指定日期时间解析时的格式

日期时间解析格式，可参考该文档： https://docs.rs/chrono/latest/chrono/format/strftime/index.html

df = pl.read_csv("./data/apple_stock.csv", try_parse_dates=False)

df = df.with_columns(pl.col("Date").str.to_date("%Y-%m-%d"))
print(df)
shape: (100, 2)
┌────────────┬────────┐
│ Date       ┆ Close  │
│ ---        ┆ ---    │
│ date       ┆ f64    │
╞════════════╪════════╡
│ 1981-02-23 ┆ 24.62  │
│ 1981-05-06 ┆ 27.38  │
│ 1981-05-18 ┆ 28.0   │
│ 1981-09-25 ┆ 14.25  │
│ 1982-07-08 ┆ 11.0   │
│ …          ┆ …      │
│ 2012-05-16 ┆ 546.08 │
│ 2012-12-04 ┆ 575.85 │
│ 2013-07-05 ┆ 417.42 │
│ 2013-11-07 ┆ 512.49 │
│ 2014-02-25 ┆ 522.06 │
└────────────┴────────┘

从日期时间类型中提取特定的日期类型

比如从日期时间类型列中提取年份、日期等，通过 .dt 来提取

df_with_year = df.with_columns(pl.col("Date").dt.year().alias("year"))
print(df_with_year)
#shape: (100, 3)
┌────────────┬────────┬──────┐
│ Date       ┆ Close  ┆ year │
│ ---        ┆ ---    ┆ ---  │
│ date       ┆ f64    ┆ i32  │
╞════════════╪════════╪══════╡
│ 1981-02-23 ┆ 24.62  ┆ 1981 │
│ 1981-05-06 ┆ 27.38  ┆ 1981 │
│ 1981-05-18 ┆ 28.0   ┆ 1981 │
│ 1981-09-25 ┆ 14.25  ┆ 1981 │
│ 1982-07-08 ┆ 11.0   ┆ 1982 │
│ …          ┆ …      ┆ …    │
│ 2012-05-16 ┆ 546.08 ┆ 2012 │
│ 2012-12-04 ┆ 575.85 ┆ 2012 │
│ 2013-07-05 ┆ 417.42 ┆ 2013 │
│ 2013-11-07 ┆ 512.49 ┆ 2013 │
│ 2014-02-25 ┆ 522.06 ┆ 2014 │
└────────────┴────────┴──────┘

混合时差

当有混合时差（例如，由于跨越夏令时），可以使用 dt.convert_time_zone 来进行转换

data = [
    "2021-03-27T00:00:00+0100",
    "2021-03-28T00:00:00+0100",
    "2021-03-29T00:00:00+0200",
    "2021-03-30T00:00:00+0200",
]
mixed_parsed = (
    pl.Series(data)
    .str.to_datetime("%Y-%m-%dT%H:%M:%S%z")
    .dt.convert_time_zone("Europe/Brussels")
)


print(mixed_parsed)
#shape: (4,)
Series: '' [datetime[μs, Europe/Brussels]]
[
	2021-03-27 00:00:00 CET
	2021-03-28 00:00:00 CET
	2021-03-29 00:00:00 CEST
	2021-03-30 00:00:00 CEST
]

日期时间数据筛选

from datetime import datetime

df = pl.read_csv("./data/apple_stock.csv", try_parse_dates=True)

print(df)
#shape: (100, 2)
┌────────────┬────────┐
│ Date       ┆ Close  │
│ ---        ┆ ---    │
│ date       ┆ f64    │
╞════════════╪════════╡
│ 1981-02-23 ┆ 24.62  │
│ 1981-05-06 ┆ 27.38  │
│ 1981-05-18 ┆ 28.0   │
│ 1981-09-25 ┆ 14.25  │
│ 1982-07-08 ┆ 11.0   │
│ …          ┆ …      │
│ 2012-05-16 ┆ 546.08 │
│ 2012-12-04 ┆ 575.85 │
│ 2013-07-05 ┆ 417.42 │
│ 2013-11-07 ┆ 512.49 │
│ 2014-02-25 ┆ 522.06 │
└────────────┴────────┘

筛选单个日期时间对象

filtered_df = df.filter(
    pl.col("Date") == datetime(1995, 10, 16),
)
print(filtered_df)
#shape: (1, 2)
┌────────────┬───────┐
│ Date       ┆ Close │
│ ---        ┆ ---   │
│ date       ┆ f64   │
╞════════════╪═══════╡
│ 1995-10-16 ┆ 36.13 │
└────────────┴───────┘

筛选一个日期范围

通过 is_between 方法，指定一个范围

filtered_range_df = df.filter(
    pl.col("Date").is_between(datetime(1995, 7, 1), datetime(1995, 11, 1)),
)
print(filtered_range_df)
#shape: (2, 2)
┌────────────┬───────┐
│ Date       ┆ Close │
│ ---        ┆ ---   │
│ date       ┆ f64   │
╞════════════╪═══════╡
│ 1995-07-06 ┆ 47.0  │
│ 1995-10-16 ┆ 36.13 │
└────────────┴───────┘

筛选负数日期

考古领域数据可能会涉及这类日期

ts = pl.Series(["-1300-05-23", "-1400-03-02"]).str.to_date()

negative_dates_df = pl.DataFrame({"ts": ts, "values": [3, 4]})

negative_dates_filtered_df = negative_dates_df.filter(pl.col("ts").dt.year() < -1300)
print(negative_dates_filtered_df)
#shape: (1, 2)
┌─────────────┬────────┐
│ ts          ┆ values │
│ ---         ┆ ---    │
│ date        ┆ i64    │
╞═════════════╪════════╡
│ -1400-03-02 ┆ 4      │
└─────────────┴────────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-09_数据框关联与拼接

Tue, 23 Jul 2024 00:00:00 GMT

背景

polars学习系列文章，第9篇数据框关联与拼接（Join 、Concat）

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 1.2.1

数据框关联 Join

polars 通过指定参数 how，支持以下方式的关联：

inner：类似sql中的 inner join,取2个数据框共同的部分
left：类似sql中的 left join,取左边数据框所有数据，匹配右边数据框数据，能匹配到的进行匹配，匹配不到的用 null 填充
full：类似sql中的 full outer join，返回2个数据框的全量数据，匹配不到的用 null 填充
cross：2个数据框的笛卡尔积，数据行数为，len(A) × len(B)
semi：用的相对比较少，左边数据框中关联字段同时存在右边数据框中，只返回左边数据框的行，有点类似 inner join,但是不全完一样，即使右边数据框有多行的，左边返回的还是单行，也就是遇到关联字段存在于右边数据框，就返回
anti：用的相对比较少，返回左边数据框中关联字段不存在右边数据框中的行，与 semi 相反

数据准备

df_customers = pl.DataFrame(
    {
        "customer_id": [1, 2, 3],
        "name": ["Alice", "Bob", "Charlie"],
    }
)

print(df_customers)
#shape: (3, 2)
┌─────────────┬─────────┐
│ customer_id ┆ name    │
│ ---         ┆ ---     │
│ i64         ┆ str     │
╞═════════════╪═════════╡
│ 1           ┆ Alice   │
│ 2           ┆ Bob     │
│ 3           ┆ Charlie │
└─────────────┴─────────┘

df_orders = pl.DataFrame(
    {
        "order_id": ["a", "b", "c"],
        "customer_id": [1, 2, 2],
        "amount": [100, 200, 300],
    }
)

print(df_orders)
#shape: (3, 3)
┌──────────┬─────────────┬────────┐
│ order_id ┆ customer_id ┆ amount │
│ ---      ┆ ---         ┆ ---    │
│ str      ┆ i64         ┆ i64    │
╞══════════╪═════════════╪════════╡
│ a        ┆ 1           ┆ 100    │
│ b        ┆ 2           ┆ 200    │
│ c        ┆ 2           ┆ 300    │
└──────────┴─────────────┴────────┘

Inner join

df_inner_customer_join = df_customers.join(df_orders, 
                                           on="customer_id", 
                                           how="inner")

print(df_inner_customer_join)
#shape: (3, 4)
┌─────────────┬───────┬──────────┬────────┐
│ customer_id ┆ name  ┆ order_id ┆ amount │
│ ---         ┆ ---   ┆ ---      ┆ ---    │
│ i64         ┆ str   ┆ str      ┆ i64    │
╞═════════════╪═══════╪══════════╪════════╡
│ 1           ┆ Alice ┆ a        ┆ 100    │
│ 2           ┆ Bob   ┆ b        ┆ 200    │
│ 2           ┆ Bob   ┆ c        ┆ 300    │
└─────────────┴───────┴──────────┴────────┘

Left join

df_left_join = df_customers.join(df_orders, 
                                 on="customer_id", 
                                 how="left")

print(df_left_join)
#shape: (4, 4)
┌─────────────┬─────────┬──────────┬────────┐
│ customer_id ┆ name    ┆ order_id ┆ amount │
│ ---         ┆ ---     ┆ ---      ┆ ---    │
│ i64         ┆ str     ┆ str      ┆ i64    │
╞═════════════╪═════════╪══════════╪════════╡
│ 1           ┆ Alice   ┆ a        ┆ 100    │
│ 2           ┆ Bob     ┆ b        ┆ 200    │
│ 2           ┆ Bob     ┆ c        ┆ 300    │
│ 3           ┆ Charlie ┆ null     ┆ null   │
└─────────────┴─────────┴──────────┴────────┘

Outer join

df_outer_join = df_customers.join(df_orders, 
                                  on="customer_id", 
                                  how="full")

print(df_outer_join)
#shape: (4, 5)
┌─────────────┬─────────┬──────────┬───────────────────┬────────┐
│ customer_id ┆ name    ┆ order_id ┆ customer_id_right ┆ amount │
│ ---         ┆ ---     ┆ ---      ┆ ---               ┆ ---    │
│ i64         ┆ str     ┆ str      ┆ i64               ┆ i64    │
╞═════════════╪═════════╪══════════╪═══════════════════╪════════╡
│ 1           ┆ Alice   ┆ a        ┆ 1                 ┆ 100    │
│ 2           ┆ Bob     ┆ b        ┆ 2                 ┆ 200    │
│ 2           ┆ Bob     ┆ c        ┆ 2                 ┆ 300    │
│ 3           ┆ Charlie ┆ null     ┆ null              ┆ null   │
└─────────────┴─────────┴──────────┴───────────────────┴────────┘

Cross join

df_colors = pl.DataFrame(
    {
        "color": ["red", "blue", "green"],
    }
)
print(df_colors)
#shape: (3, 1)
┌───────┐
│ color │
│ ---   │
│ str   │
╞═══════╡
│ red   │
│ blue  │
│ green │
└───────┘

df_sizes = pl.DataFrame(
    {
        "size": ["S", "M", "L"],
    }
)
#print(df_sizes)

df_cross_join = df_colors.join(df_sizes, 
                               how="cross")

print(df_cross_join)
#shape: (9, 2)
┌───────┬──────┐
│ color ┆ size │
│ ---   ┆ ---  │
│ str   ┆ str  │
╞═══════╪══════╡
│ red   ┆ S    │
│ red   ┆ M    │
│ red   ┆ L    │
│ blue  ┆ S    │
│ blue  ┆ M    │
│ blue  ┆ L    │
│ green ┆ S    │
│ green ┆ M    │
│ green ┆ L    │
└───────┴──────┘

Semi join

df_cars = pl.DataFrame(
    {
        "id": ["a", "b", "c"],
        "make": ["ford", "toyota", "bmw"],
    }
)
print(df_cars)
shape: (3, 2)
┌─────┬────────┐
│ id  ┆ make   │
│ --- ┆ ---    │
│ str ┆ str    │
╞═════╪════════╡
│ a   ┆ ford   │
│ b   ┆ toyota │
│ c   ┆ bmw    │
└─────┴────────┘

df_repairs = pl.DataFrame(
    {
        "id": ["c", "c"],
        "cost": [100, 200],
    }
)
print(df_repairs)
#shape: (2, 2)
┌─────┬──────┐
│ id  ┆ cost │
│ --- ┆ ---  │
│ str ┆ i64  │
╞═════╪══════╡
│ c   ┆ 100  │
│ c   ┆ 200  │
└─────┴──────┘

df_semi_join = df_cars.join(df_repairs, 
                            on="id", 
                            how="semi")
print(df_semi_join)
#shape: (1, 2)
┌─────┬──────┐
│ id  ┆ make │
│ --- ┆ ---  │
│ str ┆ str  │
╞═════╪══════╡
│ c   ┆ bmw  │
└─────┴──────┘

Anti join

df_anti_join = df_cars.join(df_repairs, 
                            on="id", 
                            how="anti")

print(df_anti_join)
#shape: (2, 2)
┌─────┬────────┐
│ id  ┆ make   │
│ --- ┆ ---    │
│ str ┆ str    │
╞═════╪════════╡
│ a   ┆ ford   │
│ b   ┆ toyota │
└─────┴────────┘

数据框拼接 Concat

有以下3种方式的数据框拼接：

纵向拼接/垂直拼接：2个数据框有相同的字段，拼接后产生更长的数据框
横向拼接/水平拼接：2个数据框没有重叠的字段，拼接后产生更宽的数据框
对角拼接：2个数据框有不同的行与列，既有重叠的字段，也有非重叠的字段，拼接后产生即长又宽的数据框

纵向拼接/垂直拼接 Vertical concatenation

当没有相同的列字段时，纵向拼接会失败

df_v1 = pl.DataFrame(
    {
        "a": [1],
        "b": [3],
    }
)
df_v2 = pl.DataFrame(
    {
        "a": [2],
        "b": [4],
    }
)
df_vertical_concat = pl.concat(
    [
        df_v1,
        df_v2,
    ],
    how="vertical",
)
print(df_vertical_concat)
#shape: (2, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1   ┆ 3   │
│ 2   ┆ 4   │
└─────┴─────┘

横向拼接/水平拼接 Horizontal concatenation

当2个数据框有不同的行数时，拼接后短的行会用 null 进行填充

df_h1 = pl.DataFrame(
    {
        "l1": [1, 2],
        "l2": [3, 4],
    }
)
df_h2 = pl.DataFrame(
    {
        "r1": [5, 6],
        "r2": [7, 8],
        "r3": [9, 10],
    }
)
df_horizontal_concat = pl.concat(
    [
        df_h1,
        df_h2,
    ],
    how="horizontal",
)
print(df_horizontal_concat)
#shape: (2, 5)
┌─────┬─────┬─────┬─────┬─────┐
│ l1  ┆ l2  ┆ r1  ┆ r2  ┆ r3  │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╪═════╪═════╡
│ 1   ┆ 3   ┆ 5   ┆ 7   ┆ 9   │
│ 2   ┆ 4   ┆ 6   ┆ 8   ┆ 10  │
└─────┴─────┴─────┴─────┴─────┘

对角拼接 Diagonal concatenation

df_d1 = pl.DataFrame(
    {
        "a": [1],
        "b": [3],
    }
)
df_d2 = pl.DataFrame(
    {
        "a": [2],
        "d": [4],
    }
)

df_diagonal_concat = pl.concat(
    [
        df_d1,
        df_d2,
    ],
    how="diagonal",
)
print(df_diagonal_concat)
#shape: (2, 3)
┌─────┬──────┬──────┐
│ a   ┆ b    ┆ d    │
│ --- ┆ ---  ┆ ---  │
│ i64 ┆ i64  ┆ i64  │
╞═════╪══════╪══════╡
│ 1   ┆ 3    ┆ null │
│ 2   ┆ null ┆ 4    │
└─────┴──────┴──────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-08_分类数据处理

Mon, 08 Jul 2024 00:00:00 GMT

背景

polars学习系列文章，第8篇分类数据处理（Categorical data）

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

分类数据 Categorical data

分类数据就是平时在数据库中能进行编码的数据，比如：性别、年龄、国家、城市、职业等等，可以对这些数据进行编码，可以节省存储空间

Polars 支持两种不同的数据类型来处理分类数据：Enum 和 Categorical

当类别预先已知时使用 Enum，需要提前提供所有类别
当不知道类别或类别不固定时，可以使用 Categorical

enum_dtype = pl.Enum(["Polar", "Panda", "Brown"])
enum_series = pl.Series(
    ["Polar", "Panda", "Brown", "Brown", "Polar"], 
    dtype=enum_dtype)

cat_series = pl.Series(
    ["Polar", "Panda", "Brown", "Brown", "Polar"], 
    dtype=pl.Categorical
)

Categorical 类型

Categorical 相对比较灵活，不用提前获取所有的类别，当有新类别时，会自动进行编码

当对来自2个不同的 Categorical 类别列直接进行拼接时，以下这种方式会比较慢，polars 是根据字符串出现的先后顺序进行编码，不同的字符串在不同的序列里面编码可能不一样，直接合并的话全局会再进行一次编码，速度会比较慢：

cat_series = pl.Series(
    ["Polar", "Panda", "Brown", "Brown", "Polar"], dtype=pl.Categorical
)
cat2_series = pl.Series(
    ["Panda", "Brown", "Brown", "Polar", "Polar"], dtype=pl.Categorical
)

#CategoricalRemappingWarning: Local categoricals have different encodings, 
#expensive re-encoding is done to perform this merge operation. 
#Consider using a StringCache or an Enum type if the categories are known in advance
print(cat_series.append(cat2_series))

可以通过使用 polars 提供的全局字符缓存 StringCache，来提升数据处理效率

with pl.StringCache():
    cat_series = pl.Series(
        ["Polar", "Panda", "Brown", "Brown", "Polar"], dtype=pl.Categorical
    )
    cat2_series = pl.Series(
        ["Panda", "Brown", "Brown", "Polar", "Polar"], dtype=pl.Categorical
    )
    print(cat_series.append(cat2_series))

Enum

上面来自2个不同类型列进行拼接的耗时的情况，在Enum中不会存在，因为已经提前获取到了全部的类别

dtype = pl.Enum(["Polar", "Panda", "Brown"])
cat_series = pl.Series(["Polar", "Panda", "Brown", "Brown", "Polar"], dtype=dtype)
cat2_series = pl.Series(["Panda", "Brown", "Brown", "Polar", "Polar"], dtype=dtype)

print(cat_series.append(cat2_series))
#shape: (10,)
#Series: '' [enum]
[
	"Polar"
	"Panda"
	"Brown"
	"Brown"
	"Polar"
	"Panda"
	"Brown"
	"Brown"
	"Polar"
	"Polar"
]

如果有编码的字符串类别，当不在提前获取的Enum中时，则会报错：OutOfBounds

dtype = pl.Enum(["Polar", "Panda", "Brown"])
try:
    cat_series = pl.Series(["Polar", "Panda", "Brown", "Black"], dtype=dtype)
except Exception as e:
    print(e)
#conversion from `str` to `enum` failed 
#in column '' for 1 out of 4 values: ["Black"]
#Ensure that all values in the input column are present 
#in the categories of the enum datatype.

比较

Categorical vs Categorical
Categorical vs String
Enum vs Enum
Enum vs String(该字符串必须要在提前获取的Enum中)

Categorical vs Categorical

with pl.StringCache():
    cat_series = pl.Series(["Brown", "Panda", "Polar"], dtype=pl.Categorical)
    cat_series2 = pl.Series(["Polar", "Panda", "Black"], dtype=pl.Categorical)
    print(cat_series == cat_series2)
#shape: (3,)
#Series: '' [bool]
[
	false
	true
	false
]

Categorical vs String

cat_series = pl.Series(["Brown", "Panda", "Polar"], dtype=pl.Categorical)
print(cat_series <= "Cat")
#shape: (3,)
#Series: '' [bool]
[
	true
	false
	false
]

cat_series = pl.Series(["Brown", "Panda", "Polar"], dtype=pl.Categorical)
cat_series_utf = pl.Series(["Panda", "Panda", "A Polar"])
print(cat_series <= cat_series_utf)
#shape: (3,)
#Series: '' [bool]
[
	true
	true
	false
]

Enum vs Enum

dtype = pl.Enum(["Polar", "Panda", "Brown"])
cat_series = pl.Series(["Brown", "Panda", "Polar"], dtype=dtype)
cat_series2 = pl.Series(["Polar", "Panda", "Brown"], dtype=dtype)
print(cat_series == cat_series2)
#shape: (3,)
#Series: '' [bool]
[
	false
	true
	false
]

Enum vs String(该字符串必须要在提前获取的Enum中)

try:
    cat_series = pl.Series(
        ["Low", "Medium", "High"], dtype=pl.Enum(["Low", "Medium", "High"])
    )
    cat_series <= "Excellent"
except Exception as e:
    print(e)
#conversion from `str` to `enum` failed 
#in column '' for 1 out of 1 values: ["Excellent"]
#Ensure that all values in the input column are present 
#in the categories of the enum datatype.

dtype = pl.Enum(["Low", "Medium", "High"])
cat_series = pl.Series(["Low", "Medium", "High"], dtype=dtype)
print(cat_series <= "Medium")
#shape: (3,)
#Series: '' [bool]
[
	true
	true
	false
]

dtype = pl.Enum(["Low", "Medium", "High"])
cat_series = pl.Series(["Low", "Medium", "High"], dtype=dtype)
cat_series2 = pl.Series(["High", "High", "Low"])
print(cat_series <= cat_series2)
#shape: (3,)
#Series: '' [bool]
[
	true
	true
	false
]

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-07_缺失值

Tue, 25 Jun 2024 00:00:00 GMT

背景

polars学习系列文章，第7篇缺失值

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

polars 中缺失值的定义

在 polars 中缺失值用 null 来表示，只有这1种表示方式，这个与 pandas 不同，在 pandas 中 NaN（NotaNumber）也代表是缺失值，但在polars中把 NaN 归属为一种浮点数据

df = pl.DataFrame(
    {
        "value": [1,2,3, None,5,6,None,8,9],
    },
)
print(df)
#shape: (9, 1)
┌───────┐
│ value │
│ ---   │
│ i64   │
╞═══════╡
│ 1     │
│ 2     │
│ 3     │
│ null  │
│ 5     │
│ 6     │
│ null  │
│ 8     │
│ 9     │
└───────┘

polars中缺失值包括的2种元信息

缺失值数量，可以通过 null_count 方法来快速获取，因为已经是计算好的，所以调用该方法会立即返回结果
有效位图（validity bitmap），代表是否是缺失值，在内存中用 0 或 1 进行编码来表示，所占的内存空间非常小，通常占用空间为（数据框长度 / 8) bytes，通过 is_null 方法来查看数据是否是缺失值

null_count_df = df.null_count()
print(null_count_df)
#shape: (1, 1)
┌───────┐
│ value │
│ ---   │
│ u32   │
╞═══════╡
│ 2     │
└───────┘


is_null_series = df.select(
    pl.col("value").is_null(),
)
print(is_null_series)
#shape: (9, 1)
┌───────┐
│ value │
│ ---   │
│ bool  │
╞═══════╡
│ false │
│ false │
│ false │
│ true  │
│ false │
│ false │
│ true  │
│ false │
│ false │
└───────┘

缺失值填充

缺失值填充主要通过 fill_null方法来处理，但是需求指定填充缺失值的方法

常量，比如用 0 来填充
填充策略，例如：向前、向后等
通过表达式，比如利用其他列来填充
插值法

df = pl.DataFrame(
    {
        "col1": [1, 2, 3],
        "col2": [1, None, 3],
    },
)
print(df)
#shape: (3, 2)
┌──────┬──────┐
│ col1 ┆ col2 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ 1    ┆ 1    │
│ 2    ┆ null │
│ 3    ┆ 3    │
└──────┴──────┘

常量填充

fill_literal_df = df.with_columns(
    fill=pl.col("col2").fill_null(pl.lit(2)),
)
print(fill_literal_df)
#shape: (3, 3)
┌──────┬──────┬──────┐
│ col1 ┆ col2 ┆ fill │
│ ---  ┆ ---  ┆ ---  │
│ i64  ┆ i64  ┆ i64  │
╞══════╪══════╪══════╡
│ 1    ┆ 1    ┆ 1    │
│ 2    ┆ null ┆ 2    │
│ 3    ┆ 3    ┆ 3    │
└──────┴──────┴──────┘

填充策略

填充策略：{'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'}

fill_df = df.with_columns(
    forward=pl.col("col2").fill_null(strategy="forward"),
    backward=pl.col("col2").fill_null(strategy="backward"),
)
print(fill_df)
#shape: (3, 4)
┌──────┬──────┬─────────┬──────────┐
│ col1 ┆ col2 ┆ forward ┆ backward │
│ ---  ┆ ---  ┆ ---     ┆ ---      │
│ i64  ┆ i64  ┆ i64     ┆ i64      │
╞══════╪══════╪═════════╪══════════╡
│ 1    ┆ 1    ┆ 1       ┆ 1        │
│ 2    ┆ null ┆ 1       ┆ 3        │
│ 3    ┆ 3    ┆ 3       ┆ 3        │
└──────┴──────┴─────────┴──────────┘

通过表达式

fill_median_df = df.with_columns(
    fill=pl.col("col2").fill_null(pl.median("col2")), #类型会转换为浮点型
)
print(fill_median_df)
#shape: (3, 3)
┌──────┬──────┬──────┐
│ col1 ┆ col2 ┆ fill │
│ ---  ┆ ---  ┆ ---  │
│ i64  ┆ i64  ┆ f64  │
╞══════╪══════╪══════╡
│ 1    ┆ 1    ┆ 1.0  │
│ 2    ┆ null ┆ 2.0  │
│ 3    ┆ 3    ┆ 3.0  │
└──────┴──────┴──────┘

通过插值法

fill_interpolation_df = df.with_columns(
    fill=pl.col("col2").interpolate(),  
)
print(fill_interpolation_df)
#shape: (3, 3)
┌──────┬──────┬──────┐
│ col1 ┆ col2 ┆ fill │
│ ---  ┆ ---  ┆ ---  │
│ i64  ┆ i64  ┆ f64  │
╞══════╪══════╪══════╡
│ 1    ┆ 1    ┆ 1.0  │
│ 2    ┆ null ┆ 2.0  │
│ 3    ┆ 3    ┆ 3.0  │
└──────┴──────┴──────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-06_Lazy-Eager-API

Thu, 20 Jun 2024 00:00:00 GMT

背景

polars学习系列文章，第6篇 Lazy / Eager API Lazy： 延迟、惰性 Eager： 即时、实时

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

Lazy / Eager API 区别

Eager API（即时、实时） 实时进行计算，每一步操作都会进行计算，类似pandas那样，每操作一步都会进行计算，得到这一步的结果，所见即所得，如果没有明确指定或者调用特定的方法之外，polars 基本都是使用该模式
Lazy API（延迟、惰性） 推迟进行计算，把所有的操作步骤先记下来，Query plan（查询计划），等到需要结果时，才统一进行计算，polars 会对这些计算步骤自动进行优化，提升性能
- pl.scan_csv 等 pl.scan_ 函数
- 调用DataFrame 的 .lazy 方法，转换为 Lazy 模式

Eager API 数据处理案例

df = pl.read_csv("./data/iris.csv")
df_small = df.filter(pl.col("Sepal.Length") > 5)
df_agg = df_small.group_by("Species").agg(pl.col("Sepal.Width").mean())
print(df_agg)

#shape: (3, 2)
┌────────────┬─────────────┐
│ Species    ┆ Sepal.Width │
│ ---        ┆ ---         │
│ str        ┆ f64         │
╞════════════╪═════════════╡
│ versicolor ┆ 2.804255    │
│ virginica  ┆ 2.983673    │
│ setosa     ┆ 3.713636    │
└────────────┴─────────────┘

Lazy API 数据处理案例

q = (
    pl.scan_csv("./data/iris.csv")
    .filter(pl.col("Sepal.Length") > 5)
    .group_by("Species")
    .agg(pl.col("Sepal.Width").mean())
)

df = q.collect()
print(df)

#shape: (3, 2)
┌────────────┬─────────────┐
│ Species    ┆ Sepal.Width │
│ ---        ┆ ---         │
│ str        ┆ f64         │
╞════════════╪═════════════╡
│ virginica  ┆ 2.983673    │
│ versicolor ┆ 2.804255    │
│ setosa     ┆ 3.713636    │
└────────────┴─────────────┘

在数据处理中会对Sepal.Length进行过滤，polars 在把数据加载进内存时，只会加载符合条件的数据行，同时计算时只用到了 Species、Sepal.Width 2列，polars 只会加载这2 列到内存，进行计算

这样的话会显著降低内存和CPU的负载，从而能够在内存中容纳更大的数据集并加快处理速度

使用建议

如果你是在进行探索性分析，想知道中间的每个步骤数据情况，那么可以使用 Eager 模式
如果想得到最终的计算结果，那么可以使用 Lazy 模式，让polars对中间的计算进行优化，提升数据处理效率

注：在大部分情况下，Eager API 背后其实调用的是 Lazy API，Eager 模式其实也是有查询优化

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-05_包含的数据结构

Fri, 14 Jun 2024 00:00:00 GMT

背景

polars学习系列文章，第5篇包含的数据结构，与 pandas 一样，polars 包含的数据结构是：Series、DataFrame，大部分操作与pandas 保持一致，减少了大家的学习难度

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

Series 数据列

Series 是一维的数据结构，其有相同的数据类型，可以理解为数据库中的一列

import polars as pl

s = pl.Series("a", [1, 2, 3, 4, 5])
print(s)

shape: (5,)
Series: 'a' [i64]
[
	1
	2
	3
	4
	5
]

数据列的操作

print(s.min())  #1
print(s.max())  #5
print(s.mean())  #3.0
print(s.count())   #5

DataFrame 数据框

DataFrame 是一个二维的数据结构，其是由一系列的 Series 组成，可以理解为一张数据表，包含很多列

from datetime import datetime

df = pl.DataFrame(
    {
        "integer": [1, 2, 3, 4, 5],
        "date": [
            datetime(2022, 1, 1),
            datetime(2022, 1, 2),
            datetime(2022, 1, 3),
            datetime(2022, 1, 4),
            datetime(2022, 1, 5),
        ],
        "float": [4.0, 5.0, 6.0, 7.0, 8.0],
    }
)

print(df)

shape: (5, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 1       ┆ 2022-01-01 00:00:00 ┆ 4.0   │
│ 2       ┆ 2022-01-02 00:00:00 ┆ 5.0   │
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
│ 4       ┆ 2022-01-04 00:00:00 ┆ 7.0   │
│ 5       ┆ 2022-01-05 00:00:00 ┆ 8.0   │
└─────────┴─────────────────────┴───────┘

Head

默认展示前5行数据，也可以传出要展示的行数

print(df.head())
#shape: (5, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 1       ┆ 2022-01-01 00:00:00 ┆ 4.0   │
│ 2       ┆ 2022-01-02 00:00:00 ┆ 5.0   │
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
│ 4       ┆ 2022-01-04 00:00:00 ┆ 7.0   │
│ 5       ┆ 2022-01-05 00:00:00 ┆ 8.0   │
└─────────┴─────────────────────┴───────┘

print(df.head(3))
#shape: (3, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 1       ┆ 2022-01-01 00:00:00 ┆ 4.0   │
│ 2       ┆ 2022-01-02 00:00:00 ┆ 5.0   │
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
└─────────┴─────────────────────┴───────┘

Tail

默认展示最后5行数据，也可以传出要展示的行数

print(df.tail())
#shape: (5, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 1       ┆ 2022-01-01 00:00:00 ┆ 4.0   │
│ 2       ┆ 2022-01-02 00:00:00 ┆ 5.0   │
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
│ 4       ┆ 2022-01-04 00:00:00 ┆ 7.0   │
│ 5       ┆ 2022-01-05 00:00:00 ┆ 8.0   │
└─────────┴─────────────────────┴───────┘

print(df.tail(3))
#shape: (3, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
│ 4       ┆ 2022-01-04 00:00:00 ┆ 7.0   │
│ 5       ┆ 2022-01-05 00:00:00 ┆ 8.0   │
└─────────┴─────────────────────┴───────┘

Sample 随机抽样

print(df.sample(3))
#shape: (3, 3)
┌─────────┬─────────────────────┬───────┐
│ integer ┆ date                ┆ float │
│ ---     ┆ ---                 ┆ ---   │
│ i64     ┆ datetime[μs]        ┆ f64   │
╞═════════╪═════════════════════╪═══════╡
│ 5       ┆ 2022-01-05 00:00:00 ┆ 8.0   │
│ 3       ┆ 2022-01-03 00:00:00 ┆ 6.0   │
│ 1       ┆ 2022-01-01 00:00:00 ┆ 4.0   │
└─────────┴─────────────────────┴───────┘

Describe 数据概况

print(df.describe())
#shape: (9, 4)
┌────────────┬──────────┬─────────────────────┬──────────┐
│ statistic  ┆ integer  ┆ date                ┆ float    │
│ ---        ┆ ---      ┆ ---                 ┆ ---      │
│ str        ┆ f64      ┆ str                 ┆ f64      │
╞════════════╪══════════╪═════════════════════╪══════════╡
│ count      ┆ 5.0      ┆ 5                   ┆ 5.0      │
│ null_count ┆ 0.0      ┆ 0                   ┆ 0.0      │
│ mean       ┆ 3.0      ┆ 2022-01-03 00:00:00 ┆ 6.0      │
│ std        ┆ 1.581139 ┆ null                ┆ 1.581139 │
│ min        ┆ 1.0      ┆ 2022-01-01 00:00:00 ┆ 4.0      │
│ 25%        ┆ 2.0      ┆ 2022-01-02 00:00:00 ┆ 5.0      │
│ 50%        ┆ 3.0      ┆ 2022-01-03 00:00:00 ┆ 6.0      │
│ 75%        ┆ 4.0      ┆ 2022-01-04 00:00:00 ┆ 7.0      │
│ max        ┆ 5.0      ┆ 2022-01-05 00:00:00 ┆ 8.0      │
└────────────┴──────────┴─────────────────────┴──────────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-04_字符串数据处理

Thu, 23 May 2024 00:00:00 GMT

背景

polars学习系列文章，第4篇字符串数据处理 该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.9

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

字符串长度

可以获取字符串中的字符数或者字节数

df = pl.DataFrame({"animal": ["Crab", "cat and dog", "rab$bit", '张',None]})

out = df.select(
    pl.col("animal").str.len_bytes().alias("byte_count"),  #字节数
    pl.col("animal").str.len_chars().alias("letter_count"),  #字符串数
)
print(out)

shape: (5, 2)
┌────────────┬──────────────┐
│ byte_count ┆ letter_count │
│ ---        ┆ ---          │
│ u32        ┆ u32          │
╞════════════╪══════════════╡
│ 4          ┆ 4            │
│ 11         ┆ 11           │
│ 7          ┆ 7            │
│ 3          ┆ 1            │
│ null       ┆ null         │
└────────────┴──────────────┘

判断是否包含特定字符串或正则字符串

contains：包含指定的字符串，或正则表达式字符串，返回ture/false
starts_with：判断是否以指定的字符串开头，返回ture/false
ends_with：判断是否以指定的字符串结尾，返回ture/false

如果包含了特殊的字符，但又不是正则表达式，需要设置参数literal=True,literal默认是 False,代表字符是正则表达式字符串

out = df.select(
    pl.col("animal"),
    pl.col("animal").str.contains("cat|bit").alias("regex"),
    pl.col("animal").str.contains("rab$", literal=True).alias("literal"),  #匹配$原始字符
    pl.col("animal").str.contains("rab$").alias("regex_pattern"),
    pl.col("animal").str.starts_with("rab").alias("starts_with"),
    pl.col("animal").str.ends_with("dog").alias("ends_with"),
)
print(out)

shape: (5, 6)
┌─────────────┬───────┬─────────┬───────────────┬─────────────┬───────────┐
│ animal      ┆ regex ┆ literal ┆ regex_pattern ┆ starts_with ┆ ends_with │
│ ---         ┆ ---   ┆ ---     ┆ ---           ┆ ---         ┆ ---       │
│ str         ┆ bool  ┆ bool    ┆ bool          ┆ bool        ┆ bool      │
╞═════════════╪═══════╪═════════╪═══════════════╪═════════════╪═══════════╡
│ Crab        ┆ false ┆ false   ┆ true          ┆ false       ┆ false     │
│ cat and dog ┆ true  ┆ false   ┆ false         ┆ false       ┆ true      │
│ rab$bit     ┆ true  ┆ true    ┆ false         ┆ true        ┆ false     │
│ 张          ┆ false ┆ false   ┆ false         ┆ false       ┆ false     │
│ null        ┆ null  ┆ null    ┆ null          ┆ null        ┆ null      │
└─────────────┴───────┴─────────┴───────────────┴─────────────┴───────────┘

正则表达式的各种标识，需要写到字符串开始，用括号括起来，(?iLmsuxU)

out=pl.DataFrame({"s": ["AAA", "aAa", "aaa"]}).with_columns(
    default_match=pl.col("s").str.contains("AA"),
    insensitive_match=pl.col("s").str.contains("(?i)AA")  #忽略大小写
)

print(out)

shape: (3, 3)
┌─────┬───────────────┬───────────────────┐
│ s   ┆ default_match ┆ insensitive_match │
│ --- ┆ ---           ┆ ---               │
│ str ┆ bool          ┆ bool              │
╞═════╪═══════════════╪═══════════════════╡
│ AAA ┆ true          ┆ true              │
│ aAa ┆ false         ┆ true              │
│ aaa ┆ false         ┆ true              │
└─────┴───────────────┴───────────────────┘

根据正则表达式提取特定字符

使用extract方法，根据提供的正则表达式模式，进行提取匹配到的字符串,需要提供想要获取的组索引 group_index，默认是第1个

df = pl.DataFrame(
    {
        "a": [
            "http://vote.com/ballon_dor?candidate=messi&ref=polars",
            "http://vote.com/ballon_dor?candidat=jorginho&ref=polars",
            "http://vote.com/ballon_dor?candidate=ronaldo&ref=polars",
        ]
    }
)
out = df.select(
    a1=pl.col("a").str.extract(r"candidate=(\w+)", group_index=1),
    a2=pl.col("a").str.extract(r"candidate=(\w+)", group_index=0),
    a3=pl.col("a").str.extract(r"candidate=(\w+)")  #默认获取第1个
)
print(out)

shape: (3, 3)
┌─────────┬───────────────────┬─────────┐
│ a1      ┆ a2                ┆ a3      │
│ ---     ┆ ---               ┆ ---     │
│ str     ┆ str               ┆ str     │
╞═════════╪═══════════════════╪═════════╡
│ messi   ┆ candidate=messi   ┆ messi   │
│ null    ┆ null              ┆ null    │
│ ronaldo ┆ candidate=ronaldo ┆ ronaldo │
└─────────┴───────────────────┴─────────┘

如果想获取所有正则表达式匹配到的字符串，需要使用 extract_all 方法，结果是一个列表

df = pl.DataFrame({"foo": ["123 bla 45 asd", "xyz 678 910t"]})
out = df.select(
    pl.col("foo").str.extract_all(r"(\d+)").alias("extracted_nrs"),
)
print(out)

shape: (2, 1)
┌────────────────┐
│ extracted_nrs  │
│ ---            │
│ list[str]      │
╞════════════════╡
│ ["123", "45"]  │
│ ["678", "910"] │
└────────────────┘

字符串替换

replace：替换第一次匹配到的字符串，为新的字符串
replace_all：替换所有匹配到的字符串，为新的字符串

df = pl.DataFrame({"id": [1, 2], "text": ["abc123abc", "abc456"]})
out = df.with_columns(
    s1=pl.col("text").str.replace(r"abc\b", "ABC"), #\b 字符串结束位置，以 abc 出现在字符串结尾处
    s2=pl.col("text").str.replace("a", "-"), #只替换第一次出现的 a
    s3=pl.col("text").str.replace_all("a", "-", literal=True) #替换所有的 a
)
print(out)

shape: (2, 5)
┌─────┬───────────┬───────────┬───────────┬───────────┐
│ id  ┆ text      ┆ s1        ┆ s2        ┆ s3        │
│ --- ┆ ---       ┆ ---       ┆ ---       ┆ ---       │
│ i64 ┆ str       ┆ str       ┆ str       ┆ str       │
╞═════╪═══════════╪═══════════╪═══════════╪═══════════╡
│ 1   ┆ abc123abc ┆ abc123ABC ┆ -bc123abc ┆ -bc123-bc │
│ 2   ┆ abc456    ┆ abc456    ┆ -bc456    ┆ -bc456    │
└─────┴───────────┴───────────┴───────────┴───────────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-03_数据类型转换

Mon, 13 May 2024 00:00:00 GMT

背景

polars学习系列文章，第3篇数据类型转换 该系列文章会分享到github，大家可以去下载jupyter文件

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.5 

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

数据类型转换

数据类型转换，主要是通过 cast 方法来进行操作，该方法中有个参数 strict ，该参数决定当原数据类型不能转换为目标数据类型时，应该如何处理

严格模式， strict=True(该参数默认是True)，就会进行报错，打印出详细的错误信息
非严格模式， strict=False ,不会报错，无法转换为目标数据类型的值都会被置为 null

pandas 中数据类型转换使用的是 astype 方法

示例

数值类型 Numerics

浮点型数值转换为整型时，会向下取整；大范围的数据类型转换为小范围数据类型时，如果数值溢出时，默认会报错，如果设置了 strict=False，则会被置为 null

df = pl.DataFrame(
    {
        "integers": [1, 2, 3, 4, 5],
        "big_integers": [1, 10000002, 3, 10000004, 10000005],
        "floats": [4.0, 5.0, 6.0, 7.0, 8.0],
        "floats_with_decimal": [4.532, 5.5, 6.5, 7.5, 8.5],
    }
)

print(df)
shape: (5, 4)
┌──────────┬──────────────┬────────┬─────────────────────┐
│ integers ┆ big_integers ┆ floats ┆ floats_with_decimal │
│ ---      ┆ ---          ┆ ---    ┆ ---                 │
│ i64      ┆ i64          ┆ f64    ┆ f64                 │
╞══════════╪══════════════╪════════╪═════════════════════╡
│ 1        ┆ 1            ┆ 4.0    ┆ 4.532               │
│ 2        ┆ 10000002     ┆ 5.0    ┆ 5.5                 │
│ 3        ┆ 3            ┆ 6.0    ┆ 6.5                 │
│ 4        ┆ 10000004     ┆ 7.0    ┆ 7.5                 │
│ 5        ┆ 10000005     ┆ 8.0    ┆ 8.5                 │
└──────────┴──────────────┴────────┴─────────────────────┘

out=df.select(
        pl.col("integers").cast(pl.Float32).alias("integers_as_floats"),
        pl.col("floats").cast(pl.Int32).alias("floats_as_integers"),
        pl.col("floats_with_decimal").cast(pl.Int32).alias("floats_with_decimal_as_integers")
    )

print(out)
shape: (5, 3)
┌────────────────────┬────────────────────┬─────────────────────────────────┐
│ integers_as_floats ┆ floats_as_integers ┆ floats_with_decimal_as_integers │
│ ---                ┆ ---                ┆ ---                             │
│ f32                ┆ i32                ┆ i32                             │
╞════════════════════╪════════════════════╪═════════════════════════════════╡
│ 1.0                ┆ 4                  ┆ 4                               │
│ 2.0                ┆ 5                  ┆ 5                               │
│ 3.0                ┆ 6                  ┆ 6                               │
│ 4.0                ┆ 7                  ┆ 7                               │
│ 5.0                ┆ 8                  ┆ 8                               │
└────────────────────┴────────────────────┴─────────────────────────────────┘

#如果不溢出的类型转换，可以节省内存
out=df.select(
        pl.col("integers").cast(pl.Int16).alias("integers_smallfootprint"),
        pl.col("floats").cast(pl.Float32).alias("floats_smallfootprint"),
    )

print(out)
shape: (5, 2)
┌─────────────────────────┬───────────────────────┐
│ integers_smallfootprint ┆ floats_smallfootprint │
│ ---                     ┆ ---                   │
│ i16                     ┆ f32                   │
╞═════════════════════════╪═══════════════════════╡
│ 1                       ┆ 4.0                   │
│ 2                       ┆ 5.0                   │
│ 3                       ┆ 6.0                   │
│ 4                       ┆ 7.0                   │
│ 5                       ┆ 8.0                   │
└─────────────────────────┴───────────────────────┘

try:
    out = df.select(pl.col("big_integers").cast(pl.Int8))
    print(out)
except Exception as e:
    print(e)
#conversion from `i64` to `i8` failed in column 'big_integers' for 3 out of 5 values: [10000002, 10000004, 10000005]

out=df.select(pl.col("big_integers").cast(pl.Int8, strict=False))
print(out)
shape: (5, 1)
┌──────────────┐
│ big_integers │
│ ---          │
│ i8           │
╞══════════════╡
│ 1            │
│ null         │
│ 3            │
│ null         │
│ null         │
└──────────────┘

字符串类型 Strings

df = pl.DataFrame(
    {
        "integers": [1, 2, 3, 4, 5],
        "float": [4.0, 5.03, 6.0, 7.0, 8.0],
        "floats_as_string": ["4.0", "5.0", "6.0", "7.0", "8.0"],
    }
)

print(df)
shape: (5, 3)
┌──────────┬───────┬──────────────────┐
│ integers ┆ float ┆ floats_as_string │
│ ---      ┆ ---   ┆ ---              │
│ i64      ┆ f64   ┆ str              │
╞══════════╪═══════╪══════════════════╡
│ 1        ┆ 4.0   ┆ 4.0              │
│ 2        ┆ 5.03  ┆ 5.0              │
│ 3        ┆ 6.0   ┆ 6.0              │
│ 4        ┆ 7.0   ┆ 7.0              │
│ 5        ┆ 8.0   ┆ 8.0              │
└──────────┴───────┴──────────────────┘

out=df.select(
        pl.col("integers").cast(pl.String),
        pl.col("float").cast(pl.String),
        pl.col("floats_as_string").cast(pl.Float64),
    )

print(out)
shape: (5, 3)
┌──────────┬───────┬──────────────────┐
│ integers ┆ float ┆ floats_as_string │
│ ---      ┆ ---   ┆ ---              │
│ str      ┆ str   ┆ f64              │
╞══════════╪═══════╪══════════════════╡
│ 1        ┆ 4.0   ┆ 4.0              │
│ 2        ┆ 5.03  ┆ 5.0              │
│ 3        ┆ 6.0   ┆ 6.0              │
│ 4        ┆ 7.0   ┆ 7.0              │
│ 5        ┆ 8.0   ┆ 8.0              │
└──────────┴───────┴──────────────────┘

df = pl.DataFrame({"strings_not_float": ["4.0", "not_a_number", "6.0", "7.0", "8.0"]})
print(df)
shape: (5, 1)
┌───────────────────┐
│ strings_not_float │
│ ---               │
│ str               │
╞═══════════════════╡
│ 4.0               │
│ not_a_number      │
│ 6.0               │
│ 7.0               │
│ 8.0               │
└───────────────────┘

#运行会报错
out=df.select(pl.col("strings_not_float").cast(pl.Float64))

#设置非严格模式，忽略错误，置为null
out=df.select(pl.col("strings_not_float").cast(pl.Float64,strict=False))
print(out)
shape: (5, 1)
┌───────────────────┐
│ strings_not_float │
│ ---               │
│ f64               │
╞═══════════════════╡
│ 4.0               │
│ null              │
│ 6.0               │
│ 7.0               │
│ 8.0               │
└───────────────────┘

布尔类型 Booleans

数值型与布尔型可以相互转换，但是不允许字符型转换为布尔型

df = pl.DataFrame(
    {
        "integers": [-1, 0, 2, 3, 4],
        "floats": [0.0, 1.0, 2.0, 3.0, 4.0],
        "bools": [True, False, True, False, True],
    }
)

print(df)
shape: (5, 3)
┌──────────┬────────┬───────┐
│ integers ┆ floats ┆ bools │
│ ---      ┆ ---    ┆ ---   │
│ i64      ┆ f64    ┆ bool  │
╞══════════╪════════╪═══════╡
│ -1       ┆ 0.0    ┆ true  │
│ 0        ┆ 1.0    ┆ false │
│ 2        ┆ 2.0    ┆ true  │
│ 3        ┆ 3.0    ┆ false │
│ 4        ┆ 4.0    ┆ true  │
└──────────┴────────┴───────┘

out=df.select(pl.col("integers").cast(pl.Boolean), 
              pl.col("floats").cast(pl.Boolean)
             )
print(out)
shape: (5, 2)
┌──────────┬────────┐
│ integers ┆ floats │
│ ---      ┆ ---    │
│ bool     ┆ bool   │
╞══════════╪════════╡
│ true     ┆ false  │
│ false    ┆ true   │
│ true     ┆ true   │
│ true     ┆ true   │
│ true     ┆ true   │
└──────────┴────────┘

时间类型 Dates

Date 或 Datetime 等时间数据类型表示为自纪元（1970年1月1日）以来的天数（Date）和微秒数（Datetime），因此数值类型与时间数据类型能直接相互转换

字符串类型与时间类型，可以通过 dt.to_string、str.to_datetime进行相互转换

from datetime import date, datetime

df = pl.DataFrame(
    {
        "date": pl.date_range(date(2022, 1, 1), date(2022, 1, 5), eager=True),
        "datetime": pl.datetime_range(
            datetime(2022, 1, 1), datetime(2022, 1, 5), eager=True
        ),
    }
)

print(df)
shape: (5, 2)
┌────────────┬─────────────────────┐
│ date       ┆ datetime            │
│ ---        ┆ ---                 │
│ date       ┆ datetime[μs]        │
╞════════════╪═════════════════════╡
│ 2022-01-01 ┆ 2022-01-01 00:00:00 │
│ 2022-01-02 ┆ 2022-01-02 00:00:00 │
│ 2022-01-03 ┆ 2022-01-03 00:00:00 │
│ 2022-01-04 ┆ 2022-01-04 00:00:00 │
│ 2022-01-05 ┆ 2022-01-05 00:00:00 │
└────────────┴─────────────────────┘

out=df.select(pl.col("date").cast(pl.Int64),
              pl.col("datetime").cast(pl.Int64)
             )

print(out)
shape: (5, 2)
┌───────┬──────────────────┐
│ date  ┆ datetime         │
│ ---   ┆ ---              │
│ i64   ┆ i64              │
╞═══════╪══════════════════╡
│ 18993 ┆ 1640995200000000 │
│ 18994 ┆ 1641081600000000 │
│ 18995 ┆ 1641168000000000 │
│ 18996 ┆ 1641254400000000 │
│ 18997 ┆ 1641340800000000 │
└───────┴──────────────────┘

df = pl.DataFrame(
    {
        "date": pl.date_range(date(2022, 1, 1), date(2022, 1, 5), eager=True),
        "string": [
            "2022-01-01",
            "2022-01-02",
            "2022-01-03",
            "2022-01-04",
            "2022-01-05",
        ],
    }
)

print(df)
shape: (5, 2)
┌────────────┬────────────┐
│ date       ┆ string     │
│ ---        ┆ ---        │
│ date       ┆ str        │
╞════════════╪════════════╡
│ 2022-01-01 ┆ 2022-01-01 │
│ 2022-01-02 ┆ 2022-01-02 │
│ 2022-01-03 ┆ 2022-01-03 │
│ 2022-01-04 ┆ 2022-01-04 │
│ 2022-01-05 ┆ 2022-01-05 │
└────────────┴────────────┘

out=df.select(
    pl.col("date").dt.to_string("%Y-%m-%d"),
    pl.col("string").str.to_datetime("%Y-%m-%d"),
    pl.col("string").str.to_date("%Y-%m-%d").alias("string_to_data")
)

print(out)
shape: (5, 3)
┌────────────┬─────────────────────┬────────────────┐
│ date       ┆ string              ┆ string_to_data │
│ ---        ┆ ---                 ┆ ---            │
│ str        ┆ datetime[μs]        ┆ date           │
╞════════════╪═════════════════════╪════════════════╡
│ 2022-01-01 ┆ 2022-01-01 00:00:00 ┆ 2022-01-01     │
│ 2022-01-02 ┆ 2022-01-02 00:00:00 ┆ 2022-01-02     │
│ 2022-01-03 ┆ 2022-01-03 00:00:00 ┆ 2022-01-03     │
│ 2022-01-04 ┆ 2022-01-04 00:00:00 ┆ 2022-01-04     │
│ 2022-01-05 ┆ 2022-01-05 00:00:00 ┆ 2022-01-05     │
└────────────┴─────────────────────┴────────────────┘

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-02 上下文与表达式

Mon, 29 Apr 2024 00:00:00 GMT

背景

polars学习系列文章，第2篇，上下文与表达式 该系列文章会分享到github，大家可以去下载jupyter文件

仓库地址：https://github.com/DataShare-duo/polars_learn

上下文与表达式概述

官方文档表述：

Polars has developed its own Domain Specific Language (DSL) for transforming data. The language is very easy to use and allows for complex queries that remain human readable. The two core components of the language are Contexts and Expressions

机器翻译： Polars 开发了自己的特定领域语言 (DSL)，用于转换数据。该语言非常容易使用，允许进行复杂的查询，但仍保持人类可读性。该语言的两个核心组成部分是上下文和表达式

小编加工后的翻译： Polars 自己设计了一套用于处理数据的功能。该功能易于使用，而且能以易理解的方式进行复杂的数据处理。上下文与表达式是该功能的两个核心组成部分。

1. Contexts 上下文 上下文是指需要计算表达式的上下文

选择：df.select(...)，df.with_columns(...)
过滤：df.filter()
分组聚合：df.group_by(...).agg(...)

2. Expressions 表达式 表达式是许多数据科学运算的核心：

选取特定的列
从一列中抽取特定的行
将一列与值相乘
从一个日期列中，提取年份
将一列字符串转换为小写
......

综上所述，在Polars中，Contexts 上下文与 Expressions 表达式，需要结合使用

小编运行环境

import sys

print('python 版本：',sys.version.split('|')[0])
#python 版本： 3.11.5 

import polars as pl

print("polars 版本：",pl.__version__)
#polars 版本： 0.20.22

演示数据

df=pl.read_csv('./data/iris.csv')

print(df.head(10))
#shape: (10, 6)
┌───────┬──────────────┬─────────────┬──────────────┬─────────────┬─────────┐
│ index ┆ Sepal.Length ┆ Sepal.Width ┆ Petal.Length ┆ Petal.Width ┆ Species │
│ ---   ┆ ---          ┆ ---         ┆ ---          ┆ ---         ┆ ---     │
│ i64   ┆ f64          ┆ f64         ┆ f64          ┆ f64         ┆ str     │
╞═══════╪══════════════╪═════════════╪══════════════╪═════════════╪═════════╡
│ 1     ┆ 5.1          ┆ 3.5         ┆ 1.4          ┆ 0.2         ┆ setosa  │
│ 2     ┆ 4.9          ┆ 3.0         ┆ 1.4          ┆ 0.2         ┆ setosa  │
│ 3     ┆ 4.7          ┆ 3.2         ┆ 1.3          ┆ 0.2         ┆ setosa  │
│ 4     ┆ 4.6          ┆ 3.1         ┆ 1.5          ┆ 0.2         ┆ setosa  │
│ 5     ┆ 5.0          ┆ 3.6         ┆ 1.4          ┆ 0.2         ┆ setosa  │
│ 6     ┆ 5.4          ┆ 3.9         ┆ 1.7          ┆ 0.4         ┆ setosa  │
│ 7     ┆ 4.6          ┆ 3.4         ┆ 1.4          ┆ 0.3         ┆ setosa  │
│ 8     ┆ 5.0          ┆ 3.4         ┆ 1.5          ┆ 0.2         ┆ setosa  │
│ 9     ┆ 4.4          ┆ 2.9         ┆ 1.4          ┆ 0.2         ┆ setosa  │
│ 10    ┆ 4.9          ┆ 3.1         ┆ 1.5          ┆ 0.1         ┆ setosa  │
└───────┴──────────────┴─────────────┴──────────────┴─────────────┴─────────┘

df.shape
#(150, 6)

选取需要的列

df.select(pl.col("Sepal.Length"))  #选取特定的列

df.select(pl.col("Sepal.Length","Petal.Length"))

df.select(pl.col("*"))  #选取所有列

df.select(pl.all())  #选取所有列

df.select(pl.col("*").exclude("index", "Species"))  #选取列时，排除特定列

df.select(pl.col("^.*Length$"))  #支持正则表达式，需要以 ^ 开始 $ 结尾

df.select(pl.col(pl.Float64))  #根据列的类型，进行选取

筛选出需要的行

df.filter(pl.col("Sepal.Length")>5)  

df.filter((pl.col("Sepal.Length")>5) & (pl.col("Petal.Length")>5))  
#需要把2个条件分别括起来！！！

df.filter((pl.col("Sepal.Length")>5) | (pl.col("Petal.Length")>5))

df.select(pl.col("Sepal.Width","Petal.Width").filter(pl.col("Sepal.Length")>5))
#根据过滤条件，选取特定列

增加新列

df.with_columns(pl.lit(10),pl.lit(2).alias("lit_5"))  #增加常数列，并设置别名

df.with_columns(pl.max("Sepal.Length").alias("max_Sepal.Length"),
                pl.min("Sepal.Length").alias("min_Sepal.Length"),
                pl.mean("Sepal.Length").alias("avg_Sepal.Length"),
                pl.std("Sepal.Length").alias("std_Sepal.Length")
               )  #有点类似窗口函数

数值列运算

df.select(pl.col("Sepal.Length"),
          (pl.col("Sepal.Length")*100).alias("Sepal.Length * 100"),
          (pl.col("Sepal.Length")/100).alias("Sepal.Length / 100"),
          (pl.col("Sepal.Length")/pl.max("Sepal.Length")).alias("Sepal.Length /max_Sepal.Length")
         )

字段串列运算

df.select(pl.col("Species"),
          pl.col("Species").str.len_bytes().alias("byte_count"),
          pl.col("Species").str.len_chars().alias("chars_count")
         )

df.select(pl.col("Species"),
          pl.col("Species").str.contains("set|vir").alias("regex"),
          pl.col("Species").str.starts_with("set").alias("starts_with"),
          pl.col("Species").str.ends_with("ca").alias("ends_with"),
         )

去重统计

df.select(pl.col("Species").n_unique())

分组聚合运算

df.group_by("Species").agg(
    pl.len(),
    pl.col("index"),
    pl.count("Sepal.Length").name.suffix("_count_1"),  #别名，另一种方式
    pl.col("Sepal.Length").count().name.suffix("_count_2"),
    pl.mean("Sepal.Length").name.suffix("_mean"),
    pl.std("Sepal.Length").name.suffix("_std"),
)

df.group_by("Species").agg(
    (pl.col("Sepal.Length")>5).sum().alias("Sepal.Length>5"),
    (pl.col("Petal.Length")>5).sum().alias("Petal.Length>5"),
)

排序

df.sort("Sepal.Length",descending=True)

df.sort(["Sepal.Length","Petal.Length"],descending=[True,False])

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

polars学习-01 读取与写入文件

Wed, 24 Apr 2024 00:00:00 GMT

背景

在Python数据处理与分析中，大家在处理数据时，使用的基本都是 Pandas ，该库非常好用。随着 Rust 的出圈，基于其开发的 Polars 库，逐渐赢得大家的喜爱，在某些功能上更优于 Pandas。于是小编在自学的过程中，逐步整理一些资料供大家参考学习，这些资料会分享到github

仓库地址：https://github.com/DataShare-duo/polars_learn

PS：为了学习 Polars，小编先了解一遍 Rust，《Rust权威指南》

小编环境

import sys
print('python 版本：',sys.version.split('|')[0])
# python 版本：3.11.5 

import polars as pl
print("polars 版本：",pl.__version__)
# polars 版本： 0.20.22

读取文件

polars读取文件数据的方式基本与pands一致，所以上手起来很方便，以下演示是在jupyter notebook中执行

读取csv文件

data_csv=pl.read_csv('./data/iris.csv')

data_csv.shape
#(150, 6)

读取 excel 文件

默认解析引擎 xlsx2csv，需要额外安装 pip install xlsx2csv
设置 engine='calamine' 时，需要额外安装 pip install fastexcel，建议用该解析引擎，速度更快

data_excel=pl.read_excel('./data/iris.xlsx',sheet_name='iris',engine='calamine')

data_excel.shape
#(150, 6)

%timeit pl.read_excel('./data/iris.xlsx',sheet_name='iris')
#13.9 ms ± 69.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit pl.read_excel('./data/iris.xlsx',sheet_name='iris',engine='calamine')  
#2.9 ms ± 69.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

读取 txt 文件

data_txt=pl.read_csv('./data/iris.txt',separator='\t')

data_txt.shape
#(150, 6)

读取网络上的文件

url='https://raw.githubusercontent.com/DataShare-duo/Data_for_ML-Deeplearning/master/iris.csv'

data_url=pl.read_csv(url)

data_url.shape
#(150, 6)

写入文件

写入csv文件

data_csv.write_csv('./data/data_write.csv')

写入excel文件 默认的浮点数为3位，可以通过 float_precision 参数进行设置

data_csv.write_excel('./data/data_write.xlsx',float_precision=1)

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 利用partial偏函数，生成不同的聚合函数

Tue, 26 Dec 2023 00:00:00 GMT

介绍

偏函数(functools.partial)，主要用来解决函数中某些参数是已知的固定值。利用偏函数的概念，可以生成一些新的函数，在调用这些新函数时，不用再传递固定值的参数，这样可以使代码更简洁

下面列举一些偏函数的巧妙使用方法，在使用偏函数时，需要从标准库functools中导入

from functools import partial

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])   
#python 版本： 3.11.4

生成不同的聚合函数

1. 创建底层的元函数、函数类

from functools import partial

def aggregation_fn_meta(aggregation_fn, values):
    return aggregation_fn(values)

def aggregation_fn_class(aggregation_fn):
    return partial(aggregation_fn_meta, aggregation_fn)

2. 基于函数类，来生成不同的聚合函数

基于内建函数创建（python中可以直接使用的函数）

sum_fn=aggregation_fn_class(sum)
sum_fn([1,2,3,4,5,1,2,10])   #28

max_fn=aggregation_fn_class(max)
max_fn([1,2,3,4,5,1,2,10])   #10

min_fn=aggregation_fn_class(min)
min_fn([1,2,3,4,5,1,2,10])

基于自定义函数创建

def count(values):
    return len(values)

count_fn=aggregation_fn_class(count)
count_fn([1,2,3,4,5,1,2,10])    #8


def distinct_count(values):
    return len(set(values))

distinct_count_fn=aggregation_fn_class(distinct_count)
distinct_count_fn([1,2,3,4,5,1,2,10])   #6

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python-字典已经是有序的，你知道吗？

Tue, 21 Nov 2023 00:00:00 GMT

背景

随着Python版本的更新，背后的一些数据结构会进行不断优化迭代，重新进行架构设计，以实现内存减少、性能提升。其中字典的底层数据结构在Python3.6版本时，重新进行了设计，从而优化了字典的内存占用

具体的底层细节这里不做过多介绍，感兴趣的同学可以看一下这篇文章： 《为什么Python 3.6以后字典有序并且效率更高？》 地址：https://zhuanlan.zhihu.com/p/73426505

该文章的评论精彩评论： 一句话解释：从Python3.6开始，dict的实现由 哈希表 改成 链式哈希表

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])   
#python 版本： 3.11.4

测试代码

#创建测试数据
keys=[chr(i) for i in range(97,123)]
values=range(1,27)

#生成字典
dic={}
for key,value in zip(keys,values):
    dic[key]=value

#打印字典
print(dic)
#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 
#'g': 7, 'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12,
# 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 
#'r': 18,'s': 19, 't': 20, 'u': 21, 'v': 22,
# 'w': 23, 'x': 24, 'y': 25, 'z': 26}


#遍历字典
for key,value in dic.items():
    print(key,':',value,end=',')
#a : 1,b : 2,d : 4,e : 5,f : 6,g : 7,h : 8,j : 10,
#k : 11,l : 12,n : 14,o : 15,p : 16,q : 17,r : 18,
#s : 19,t : 20,u : 21,v : 22,w : 23,x : 24,z : 26,

#删除测试
del dic['c']
del dic['y']
del dic['i']
del dic['m']

print(dic)
#{'a': 1, 'b': 2, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 
#'h': 8, 'j': 10, 'k': 11, 'l': 12, 'n': 14, 'o': 15,
#'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20,
#'u': 21, 'v': 22, 'w': 23, 'x': 24, 'z': 26}

结论

经过添加、删除操作可以看出，字典是按添加键值对时的先后顺序保存数据，是有序的

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 扑克牌发牌游戏

Thu, 16 Nov 2023 00:00:00 GMT

背景

最近在看《Python - 100天从新手到大师》时，运行了一下代码，感觉挺有意思。一个简单的小游戏，包含了pyhon的很多知识，分享出来，供大家参考学习

小编对扑克牌的排序进行了简单修改，使相同大小的牌放在一起

《Python - 100天从新手到大师》，感兴趣的同学可以去学习该教程 地址：https://github.com/jackfrued/Python-100-Days

发牌结果

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])   
#python 版本： 3.11.4

完整代码

"""
===========================
@Software: PyCharm
@Platform: Win10
@Author : DataShare
===========================
"""

from enum import Enum, unique
import random


@unique
class Suite(Enum):
    """花色"""

    SPADE, HEART, CLUB, DIAMOND = range(4)

    def __lt__(self, other):
        return self.value < other.value


class Card:
    """牌"""

    def __init__(self, suite, face):
        """初始化方法"""
        self.suite = suite
        self.face = face

    def show(self):
        """显示牌面"""
        suites = ['♠︎', '♥︎', '♣︎', '♦︎']
        faces = ['', 'A', '2', '3', '4', '5', '6',
                 '7', '8', '9', '10', 'J', 'Q', 'K']
        return f'{suites[self.suite.value]}{faces[self.face]}'

    def __repr__(self):
        return self.show()


class Poker:
    """扑克"""

    def __init__(self):
        self.index = 0
        self.cards = [Card(suite, face)
                      for suite in Suite
                      for face in range(1, 14)]

    def shuffle(self):
        """洗牌（随机乱序）"""
        random.shuffle(self.cards)
        self.index = 0

    def deal(self):
        """发牌"""
        card = self.cards[self.index]
        self.index += 1
        return card

    @property
    def has_more(self):
        return self.index < len(self.cards)


class Player:
    """玩家"""

    def __init__(self, name):
        self.name = name
        self.cards = []

    def get_one(self, card):
        """摸一张牌"""
        self.cards.append(card)

    def sort(self, comp=lambda card: (card.face, card.suite)):
        """整理手上的牌"""
        self.cards.sort(key=comp)


def main():
    """主函数"""
    poker = Poker()
    poker.shuffle()
    players = [Player('东邪'), Player('西毒'), 
               Player('南帝'), Player('北丐')]
    while poker.has_more:
        for player in players:
                player.get_one(poker.deal())
    for player in players:
        player.sort()
        print(player.name, end=': ')
        print(player.cards)

if __name__ == '__main__':
    main()

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

在Linux服务器上部署Jupyter-notebook

Fri, 13 Oct 2023 00:00:00 GMT

背景

小编在刚开始学习Python时，是在Python官网下载的原生版本，用的是自带的编码环境，后来了解到在数据分析、数据科学领域用Jupyter notebook比较好，于是直到现在也是一直在用Jupyter notebook，也偶尔用PyCharm做开发。在数据分析与处理中Jupyter notebook还是很方便，可以直接查看数据，可以写文档，可以画图等很多优点，感觉Jupyter notebook 就是是为了数据分析、数据挖掘、机器学习而生的

如果用过Jupyter notebook，大家都知道，它是一个网页界面，服务端和客户端分离，每次启动都会在后台运行一个cmd/terminal窗口，可以理解为服务端，而使用的浏览器界面，可以理解为客户端。既然是服务端与客户端分开的，那么服务端就可以部署到服务器上，可以充分利用服务器的计算资源、存储资源，更甚者可以用GPU资源。其实在服务器部署Jupyter notebook，做机器学习的同学，应该对这个很熟悉，但是不一定亲手部署过

浏览器-客户端

cmd-服务端

必要前提！！！

需要对Linux服务器要有所了解，如果在工作中压根就没使用过服务器，且不知道ssh，那小编劝你暂时先别看这篇文章，可以先去多学一些Python知识，后面随着知识的积累，慢慢的你就会接触到服务器

小编服务器环境

硬件：谷歌云虚拟机实例，1G内存，100G硬盘

系统：64位 Debian，Debian GNU/Linux 11

服务器部署流程

在服务器上安装Jupyter notebook，一共分为4步，最终实现在本地电脑来访问

因为Anaconda自带Jupyter notebook，并且可以创建虚拟环境，使用起来非常方便，所以强烈推荐使用Anaconda，可以让你少采坑

第1步：下载Anaconda

Anaconda 下载地址：https://www.anaconda.com/download#downloads

在服务器上直接下载（谷歌服务器下载很快）

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

第2步：安装Anaconda

在服务器上直接安装Anaconda，在安装中一直点击回车或空格键，在许可条款、最后配置的地方输入 yes 即可

在安装时确保硬盘存储空间要足够，小编在安装是最开始只有10G硬盘资源，一直报错，后来扩大硬盘后解决了

安装完成后，命令行提示符前会有多了个 (base)，这个是Anaconda默认的基础虚假环境，小编下载的是截止发文章时最新版Anaconda，里面集成的是 Python 3.11.5

bash Anaconda3-2023.09-0-Linux-x86_64.sh

第3步：对Jupyter notebook进行配置

生成配置文件，运行后会显示配置文件的存放位置

jupyter notebook --generate-config

对配置文件进行修改

## The IP address the notebook server will listen on.
#  Default: 'localhost'
# 设置可以访问的ip, 默认是localhost, 将其改为 '*'
c.NotebookApp.ip = '*'


## The directory to use for notebooks and kernels.
#  Default: ''
# 默认打开目录
c.NotebookApp.notebook_dir = '/home/data123share66/python'


## Whether to open in a browser after starting.
#                          The specific browser used is platform dependent and
#                          determined by the python standard library `webbrowser`
#                          module, unless it is overridden using the --browser
#                          (NotebookApp.browser) configuration option.
#  Default: True
# Jupyter notebook启动后是否打开浏览器, 设为 False 即可
c.NotebookApp.open_browser = False


## Hashed password to use for web authentication.
#  
#                        To generate, type in a python/IPython shell:
#  
#                          from notebook.auth import passwd; passwd()
#  
#                        The string should be of the form type:salt:hashed-
#  password.
#  Default: ''
c.NotebookApp.password = 'argon2:$argon2id$v=19$m=10240,t=10,p=8$Ny6WDdoLBm88cUMyOqgNqg$s3WObP81eU51RT2j8D8DULPM1OAPOnzYfODW8olB0xw'

小编这里在生成密码是用的 datashare ，在输入时屏幕不会显示

第4步：启动Jupyter notebook，并在本地电脑远程访问

1、服务器启动Jupyter notebook

jupyter notebook --ip=0.0.0.0 --port=9999

2、在本地电脑浏览器远程访问在浏览器输入服务器的IP地址:9999，小编这里是34.81.173.39:9999，访问后，会出现如下页面

然后输入密码 datashare 进行登录，成功登录后界面如下所示：

3、创建一个notebook，查看python版本

Jupyter 好用的扩展插件

1、安装jupyter_contrib_nbextensions 该插件会扩展jupyter的很多功能，如目录，自动补全等，在服务器终端依次运行如下命令

pip install jupyter_contrib_nbextensions

jupyter-contrib-nbextension install --user

打开jupyter会发现多了一个菜单栏 Nbextension 对Nbextension进行配置，勾选需要的功能

2、安装nb_conda

conda install nb_conda

安装完成后，需要在服务器重新启动一下Jupyter notebook，会发现多了一个菜单栏 Conda 在服务器创建一个虚拟环境 python312，然后刷新一下页面，就可以看到虚拟环境 python312

conda create -n python312 python=3.12

多个Python版本kernel配置

虽然上面已经创建了虚拟环境，并显示出来了，但是在创建新的notebook时并显示python312，因为python312存在不同的虚拟环境里面，这个需要我们再进行配置

Jupyter Notebook允许用户在同一个notebook中使用多个不同的IPython内核

1、安装Jupyter Notebook和IPython内核

conda create -n python312 python=3.12   #上面安装过的可以忽略
conda activate python312
pip install jupyter
pip install ipykernel
pip install ipywidgets

2、安装新的kernel内核

conda activate python312   #切换虚拟环境
ipython kernel install --name "python312" --user

3、服务器端重新启动Jupyter notebook 建一个python312内核的notebook，查看当前内核的python解释器版本

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 标准库之pathlib，路径操作

Wed, 27 Sep 2023 00:00:00 GMT

背景

pathlib 标准库是在 Python3.4 引入，到现在最近版 3.11 已更新了好几个版本，主要是用于路径操作，相比之前的路径操作方法 os.path 有一些优势，有兴趣的同学可以学习下

官方文档： https://docs.python.org/zh-cn/3/library/pathlib.html

小编环境

import sys

print('python 版本：',sys.version.split('|')[0])   #python 版本： 3.11.4

主要方法、函数

该模块中主要使用的是 Path 类

导入模块

from pathlib import Path

Path.cwd()   #WindowsPath('D:/桌面/Python/标准库')

Path.home()   #WindowsPath('C:/Users/admin')

获取绝对路径

file = Path('pathlib_demo1.py')
print(file)   #WindowsPath('pathlib_demo1.py')
file.resolve()  #WindowsPath('D:/桌面/Python/标准库/pathlib_demo1.py')

获取文件属性

file = Path('pathlib_demo1.py')
print(file)   #WindowsPath('pathlib_demo1.py')

file.stat()  
'''
os.stat_result(st_mode=33206, st_ino=1970324837176895, st_dev=2522074357, 
st_nlink=1, st_uid=0, st_gid=0, st_size=273, 
st_atime=1695642854, st_mtime=1695611301, st_ctime=1695611241)
'''

#文件大小
file.stat().st_size   #273B

#最近访问时间 access ，It represents the time of most recent access 
file.stat().st_atime  #1695625134.9083948

#创建时间 create，It represents the time of most recent metadata change on Unix and creation time on Windows.
file.stat().st_ctime  #1695611241.5981772

#修改时间  modify，It represents the time of most recent content modification
file.stat().st_mtime  #1695611301.1193473

for f in path.iterdir():
    print(f)
    print('is_file:',f.is_file())  #判断是否为文件
    print('is_dir:',f.is_dir())   #判断是否为文件夹
    print('='*30)

'''
D:\桌面\Python\标准库\.ipynb_checkpoints
is_file: False
is_dir: True
==============================
D:\桌面\Python\标准库\pathlib.ipynb
is_file: True
is_dir: False
==============================
D:\桌面\Python\标准库\pathlib_demo1.py
is_file: True
is_dir: False
==============================
'''

路径的各个组成部分

file=Path('D:\桌面\Python\标准库\pathlib_demo1.py')

file.name  #'pathlib_demo1.py'
file.stem  #'pathlib_demo1'
file.suffix   #'.py'
file.parent   #WindowsPath('D:/桌面/Python/标准库')
file.anchor  #'D:\\'
file.parent.parent  #WindowsPath('D:/桌面/Python')

#获取所有的父级路径，层层递进
list(file.parents)
'''
[WindowsPath('D:/桌面/Python/标准库'),
 WindowsPath('D:/桌面/Python'),
 WindowsPath('D:/桌面'),
 WindowsPath('D:/')]
'''

路径拼接

支持2种方式

#第1种方式：使用 /
Path.home() / 'dir' / 'file.txt'  #WindowsPath('C:/Users/admin/dir/file.txt')

#第2种方式：使用方法
Path.home().joinpath('dir', 'file.txt')  #WindowsPath('C:/Users/admin/dir/file.txt')

判断路径、文件是否存在

#当前文件件里面是否存在 子目录 archive/demo.txt 文件
Path("archive/demo.txt").exists()  #False

#当前文件件里面是否存在 二级子目录 dir/subdir  
Path('dir/subdir').exists()   #True

#当前文件件里面是否存在 pathlib_demo1.py 文件
Path("pathlib_demo1.py").exists()  #True

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 记录re正则模块，方便后期查找使用

Tue, 12 Sep 2023 00:00:00 GMT

前言

小编第一次了解正则，是在VBA编程时用到，当时看了很多的学习资料，来了解和学习正则。因为现在数据录入、数据存放相对都比较规范，使用正则的场景越来越少，但运用正则在杂乱的数据中提取一些有用数据还是很方便，最近阅读书籍时又看到了正则相关的内容，于是总结了一下，分享出来，供大家参考学习

官方文档：https://docs.python.org/zh-cn/3/library/re.html

Excelhome精选正则文章 正则文章：正则表达式入门与提高---VBA平台的正则学习参考资料 地址：https://club.excelhome.net/thread-1128647-1-3.html

环境与正则库版本

import sys
import re 

print('python 版本：',sys.version.split('|')[0])   #python 版本： 3.11.4
print('re 正则库版本：',re.__version__)  #re 正则库版本： 2.2.1

正则模块中的函数/方法

re.compile 将正则表达式模式编译为一个正则表达式对象，方便多次使用

import re

text='Does this text match the pattern?'
regexes=re.compile('this')
print(regexes)   #re.compile('this')
print(regexes.search(text))  #<re.Match object; span=(5, 9), match='this'>

re.search 在给定的字符串中查找/匹配正则表达式模式，首次出现的位置，如果能匹配到，则返回相应的正则表达式对象；如果匹配不到，则返回 None

import re

pattern='this'
text='Does this text match the text pattern?'

match=re.search(pattern,text)

print(match)  #<re.Match object; span=(5, 9), match='this'>
print(match.re)  #re.compile('this')
print(match.re.pattern)  #this
print(match.string)  #Does this text match the text pattern?
print(match.start())  #5
print(match.end())  #9

re.match 在给定的字符串开头进行匹配，如果在开头能与给定的正则表达式模式匹配，则返回相应的正则表达式对象；如果匹配不到，则返回 None

import re

text='Does this text match the text pattern?'

match1=re.match('Does',text)
print(match1)   #<re.Match object; span=(0, 4), match='Does'>
print(match1.span())  #(0, 4)

match2=re.match('this',text)
print(match2)  #None

re.fullmatch 如果整个字符串需要与给定的正则表达式模式匹配，则返回相应的相应的正则表达式对象；如果匹配不到，则返回 None

import re

text='Does this text match the text pattern?'

match1=re.fullmatch('Does this text match the text pattern\?',text)
print(match1)   #<re.Match object; span=(0, 38), match='Does this text match the text pattern?'>

match2=re.fullmatch('Does this text',text)
print(match2)  #None


match3=re.fullmatch('Does .* pattern\?',text)
print(match3)  #<re.Match object; span=(0, 38), match='Does this text match the text pattern?'>

re.findall 对字符串与给定的正则表达式模式，从左至右进行查找，匹配结果按照找到的顺序进行返回，返回结果是以字符串列表或字符串元组列表的形式，如果匹配不到，返回空列表的形式

import re

text='Does this text match the text pattern?'

matches1=re.findall('text',text)
print(matches1)   #['text', 'text']

matches2=re.findall('regexes',text)
print(matches2)   #[]

re.finditer 与 findall 方法类似，结果返回的是一个迭代器，并且每个元素是匹配到的正则表达式对象

import re

text='Does this text match the text pattern?'

matches1=re.finditer('text',text)
print(matches1)  #<callable_iterator object at 0x0000024D0E9018D0>
for match in matches1:
    print(match) 
    #<re.Match object; span=(10, 14), match='text'>   
    #<re.Match object; span=(25, 29), match='text'>

matches2=re.findall('regexes',text)
print(matches2)  #[]

本篇文章只介绍了几个常用的方法，重点是方法的含义，而没有介绍元字符相关的内容，如果对正则表达式感兴趣，可以深入学习拓展知识范围

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 中把一行记录拆分为多行记录

Fri, 04 Aug 2023 00:00:00 GMT

背景

业务场景：统计每个小时视频同时在线观看人数，因后台的业务数据是汇总之后的，只有开始时间、结束时间，没有每小时的详细日志数据，无法直接进行统计，所以需要对每条业务数据进行拆分，来统计每个小时的同时数

当然，如果有详细的日志数据也是直接可以统计的，但是正常情况下，日志数据会非常大，如果每个用户每30秒会产生一条数据，那么每天会产生大量的数据，如此大量的数据，很难长期保存

模拟数据与需求效果展示

对每行数据，按每小时进行拆分，结果如下所示：

创建测试数据

--创建临时表
create table test.tmp_datashare
(user_id string comment '用户id',
start_time string comment '开始时间',
end_time string comment '结束时间')
comment '业务数据'
row format delimited fields terminated by '\t' 
lines terminated by '\n';

--加载数据
load data local inpath '/tmp/datashare.txt' 
overwrite into table test.tmp_datashare;

测试数据：

数据处理过程

数据处理的要点：

需要借助以下两个函数生成连续序列，然后用开始时间与该序列进行加和，生成相应的结果 space：空格字符串函数，语法: space(int n)，返回长度为n的空字符串 posexplode：炸裂函数，会同时返回两个值，数据的下标索引、数据的值

具体代码如下：

左右滑动查看代码

set hive.cli.print.header=true;

with a as(select user_id,start_time,end_time
		from test.tmp_datashare
		),
	b as(select user_id,start_time,end_time,pos
		from a 
		lateral view posexplode(
			split(
				space(
					cast((unix_timestamp(substr(end_time,1,13),'yyyy-MM-dd HH')-
							unix_timestamp(substr(start_time,1,13),'yyyy-MM-dd HH'))/3600 as int)), 
				' ')
			) tmp as pos,val
		)
select user_id,start_time,end_time,
from_unixtime(unix_timestamp(start_time,'yyyy-MM-dd HH:mm:ss')+3600*pos,
	'yyyy-MM-dd HH') as start_time_every_hh
from b 
order by user_id,start_time_every_hh

结果数据：

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Excel中的标准差 stdev.S 和 stdev.P 区别

Fri, 30 Jun 2023 00:00:00 GMT

背景

标准差这个指标在平时使用比较多，主要是用来计算数据的离散程度，在Excel中有相关的函数，可以直接来计算，其他的编程语言里面也有相关的函数。

Excel中提供了2个函数 stdev.S 和 stdev.P ，都可以用来计算标准差，但这两者应该如何合理使用呢？又有什么区别呢？本篇文章将对这两个函数进行详细的讲解

stdev.S和stdev.P区别

1、先看微软文档给出的解释

2、源自网络文章的理解 当你只知道一小部分样本，想要通过其 【估算】 这部分 【样本代表的总体】 的 【标准差】 ——选择stdev.S（2010版之后叫stdev.S，老版叫stdev。这个S就是sample，样本的意思）

当你拿到的数据已经是 整体数据 了，想要计算这部分数据精确的标准差——选择stdev.P(2010版之后叫stdev.P，老版叫stdevP。这个P我猜是population，在统计学上有“总体”之意）

3、公式对比

stdev.S 计算公式：

$$\sqrt{\frac{\sum(x-\overline{x})^2}{n-1}}$$

stdev.P 计算公式：

$$\sqrt{\frac{\sum(x-\overline{x})^2}{n}}$$

从计算公式可以看出，唯一的区别就是根号中的分母不一样，这个涉及到自由度的概念（理解起来比较复杂），我们可以直接硬记住这个公式即可

4、总结

数据是抽取的样本时用stdev.S 【其他编程语言中用的是这个】
数据是全量时用stdev.P

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 中对相邻访问时间进行归并分组

Wed, 24 May 2023 00:00:00 GMT

背景

对用户每天的访问次数进行统计时，需要对用户访问页面相邻的时间间隔小于30分钟归并为一组（算是一次），这样可以统计出用户每天的访问次数（忽略隔天问题）。这个问题如果用python来处理可能比较方便，可以循环遍历每行，进行两两之间的比较。利用Hive来处理数据，劣势就是不能循环遍历不够灵活，但是也能处理，只是过程相对比较复杂

模拟数据与预想的效果

创建测试数据

--创建临时表
create table test.tmp_datashare
(user_id string comment '用户id',
url string comment '网页',
create_time string comment '访问时间')
comment '用户访问日志'
row format delimited fields terminated by '\t' lines terminated by '\n';

--加载数据
load data local inpath '/tmp/datashare.txt' overwrite into table test.tmp_datashare;

测试数据：

数据处理过程

数据处理的难点：

1、时间处理需要用到 UNIX_TIMESTAMP 转换为时间戳

2、运用窗口函数 LAG 提取前一行的访问时间

3、再次运用窗口函数 SUM 进行归并分组

具体代码如下：

with a as (select user_id,url,create_time,
			lag(create_time,1) over(partition by user_id order by create_time) as last_1_time
		from clwtest.tmp_datashare
	),
	b as (select user_id,url,create_time,
		case 
			when last_1_time is null then 1
			when (unix_timestamp(create_time,'yyyy-MM-dd HH:mm:ss')-
				unix_timestamp(last_1_time,'yyyy-MM-dd HH:mm:ss'))/60<30 then 0
			else 1
		end as group_tmp
	from a
	),
	c as (select user_id,url,create_time,
		sum(group_tmp) over(partition by user_id order by create_time) as group_id
	from b
	)
select user_id,url,create_time,group_id
from c
order by user_id,create_time

结果数据：

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 内建模块-bisect，数组二分查找算法

Wed, 10 May 2023 00:00:00 GMT

介绍

bisect模块提供了一种只针对 已排序的序列 的方法，快速找到插入元素的位置，这个模块使用二分查找算法，算法的时间复杂度相对更低一些，可以用于程序优化提升性能

官方文档：https://docs.python.org/3/library/bisect.html#module-bisect

函数分为 bisect、insort 两大块

各函数详解

bisect、bisect_right 这两个函数功能一模一样，bisect 是对 bisect_right 的引用，用于查找元素在已经排序的序列中应该插入的位置，返回值为最靠右 or 最大的索引位置

l = [1, 23, 45, 12, 23, 42, 54, 123, 14, 52, 3]
l.sort()

print(l)  #[1, 3, 12, 14, 23, 23, 42, 45, 52, 54, 123]
print(bisect.bisect(l, 3))  #2

bisect_left 返回值为最靠左 or 最小的索引

l = [1, 23, 45, 12, 23, 42, 54, 123, 14, 52, 3]
l.sort()

print(l)  #[1, 3, 12, 14, 23, 23, 42, 45, 52, 54, 123]
print(bisect.bisect_left(l, 3))  #1

insort、insort_right 这两个函数功能一模一样，insort 是对 insort_right 的引用，用于将一个元素插入到已经排序的序列中，并且保持序列的排序状态，插入位置为最靠右 or 最大的索引位置

l = [1, 23, 45, 12, 23, 42, 54, 123, 14, 52, 3]
l.sort()

print(l)  #[1, 3, 12, 14, 23, 23, 42, 45, 52, 54, 123]

bisect.insort(l, 3.0)
print(l)  #[1, 3, 3.0, 12, 14, 23, 23, 42, 45, 52, 54, 123]

insort_left 插入位置为最靠左 or 最小的索引位置

li = [1, 23, 45, 12, 23, 42, 54, 123, 14, 52, 3]
li.sort()

print(li)  #[1, 3, 12, 14, 23, 23, 42, 45, 52, 54, 123]

bisect.insort_left(li, 3.0)
print(li)  #[1, 3.0, 3, 12, 14, 23, 23, 42, 45, 52, 54, 123]

官方文档案例

def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
    i = bisect.bisect(breakpoints, score)
    return grades[i]

[grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
#['F', 'A', 'C', 'C', 'B', 'A', 'A']

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 标准库heapq，堆数据结构操作详解

Fri, 17 Mar 2023 00:00:00 GMT

注：本文章由ChatGPT gpt-3.5-turbo 生成，小编进行略微调整 提出的问题：heapq详细讲解

背景

最近小编在读《Python Cookbook》书籍时，遇到一个新的标准库 heapq，该库主要涉及堆数据结构，自己之前没有用过，所以就问了一下 ChatGPT，给出的内容非常详细且容易理解，分享出来供大家参考

heapq介绍

heapq 是 Python 标准库中的一个基于堆的优先队列实现。它提供了一些函数来实现对列表中的元素进行加入、弹出、替换等操作，同时也支持对列表中的元素进行建堆、堆排序等高级功能。本文将详细介绍 heapq 的使用方法和内部实现原理。

基本用法

1、heapq.heappush 和 heapq.heappop

heapq.heappush(lst, item)：将元素 item 加入到列表 lst 中，并保持 lst 始终为一个堆。

heapq.heappop(lst)：从列表 lst 中弹出最小的元素，并保持 lst 始终为一个堆。

下面是一个示例：

import heapq

lst = [10, 30, 2, 20, 50]  # 初始列表
heapq.heapify(lst)        # 建堆
print(lst)                # 输出 [2, 20, 10, 30, 50]

heapq.heappush(lst, 5)    # 将 5 加入到 lst 中
print(lst)                # 输出 [2, 5, 10, 30, 50, 20]

min_item = heapq.heappop(lst)  # 弹出最小元素
print(min_item, lst)           # 输出 2 [5, 20, 10, 30, 50]

2、heapq.heapreplace

heapq.heapreplace(lst, item)：将最小元素替换为 item，并保持 lst 始终为一个堆。

这个函数相当于先执行 heapq.heappop(lst)，再执行 heapq.heappush(lst, item)。使用该函数可以避免在先弹出再加入元素时，列表中出现不合法的状态。例如：

import heapq

lst = [10, 30, 2, 20, 50]   # 初始列表
heapq.heapify(lst)          # 建堆
print(lst)                  # 输出 [2, 20, 10, 30, 50]

heapq.heapreplace(lst, 5)   # 用 5 替换最小元素 2
print(lst)                  # 输出 [5, 20, 10, 30, 50]

3、heapq.nlargest 和 heapq.nsmallest

heapq.nlargest(n, lst)：返回列表 lst 中前 n 个最大的元素，按照从大到小的顺序排序。

heapq.nsmallest(n, lst)：返回列表 lst 中前 n 个最小的元素，按照从小到大的顺序排序。

这两个函数的实现都是先使用 heapq.heappush 和 heapq.heappop 对列表进行处理，之后返回前 n 个元素。示例：

import heapq

lst = [10, 30, 2, 20, 50]  # 初始列表
heapq.heapify(lst)        # 建堆
print(lst)                # 输出 [2, 20, 10, 30, 50]

print(heapq.nlargest(3, lst))  # 输出 [50, 30, 20]
print(heapq.nsmallest(3, lst)) # 输出 [2, 10, 20]

内部实现原理

Heap 是一种树形数据结构，通常用二叉树来实现。堆树的最上面是根节点，根节点下面的每个节点都比它自己所有的子节点都大（称为大根堆）或者都小（称为小根堆）。根据这个性质，堆树可以快速地找到最大或者最小元素。

Python 中的 heapq 模块实现是使用了一种叫做“二叉堆”的数据结构。二叉堆由固定数量的元素组成，堆的根节点包含所有能够在其中的元素中具有最小或者最大关键字的元素。我们称这个根节点为“最小堆”或者“最大堆”。堆中的每一个其他的节点都符合堆的性质：最小堆中的每一个节点都比它的子节点小；最大堆中的每一个节点都比它的子节点大。

这种数据结构可以直接用一个数组来实现，每个元素在数组中顺序存储，并按照堆的性质排列。数组的第一个元素是根节点，也就是堆的最小或最大元素。根据元素在数组中的位置，可以快速地用简单的数学运算找到它的子节点和父节点

二叉堆分为两种类型：最小堆和最大堆。在 Python 中的 heapq 模块中使用最小堆

Python 中，可以以列表的形式存储二叉堆，将列表作为二叉树，树的根节点即为第一个元素，树的子节点为列表中其左右孩子。具体来说，以第 k 个节点为例，其左孩子为第 2k+1 个节点，右孩子为第 2k+2 个节点，其父节点为第(k-1)//2 个节点

通过使用 heapq 模块提供的高效的堆算法，可以快速地实现对列表中元素的排序、寻找最大/最小值等常见操作

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 中的各种常用set设置

Wed, 23 Nov 2022 00:00:00 GMT

背景

平时在跑数据时，需要在查询语句前设置一些set语句，这些set语句中其中有一些是配置hive的各功能，另一些是可以达到优化的目的，本篇文章对一些常用的set语句进行总结

常用set设置

查询结果显示表头

执行完查询语句，输出结果时，会一起把字段的名字也打印出来

set hive.cli.print.header=true;  --默认为false，不打印表头

展示当前使用的数据库

主要是在命令行模式中使用，方便核查是否切换到相应的数据库下

set hive.cli.print.current.db=true;  --默认为false，不显示当前数据库名字

设置是否使用元数据中的统计信息

比如想要看数据一共有多少行的话，一般是从元数据中的统计信息直接获取，但有时这个统计信息没有更新，得到的是历史的统计信息，则需要修改为 false，然后再进行查询，才能统计出准确的数据

set hive.compute.query.using.stats=false;   --默认为true，使用元数据中的统计信息，提升查询效率

设置Fetch抓取，不走job，不用执行MapReduce

一般用于快速获取样例数据，select * from talbe_xxx limit 100

set hive.fetch.task.conversion=more;

设置查询任取走哪个队列

一般公司的服务器集群中会配置好几个队列，不同的队列优先级不一样，并且资源配置有可能不一样，生产环境的任务肯定优先级高、计算资源多，数据分析的任务一般是单独的队列，计算资源少

set mapreduce.job.queuename=root.db;   --运维人员设置的队列名字

是否开启严格模式

一般运维人员会设置为严格模式 strict，防止大量数据计算占用资源，多出现在笛卡尔积join时；或者查询的是分区表，但没有指定分区，明明sql语句没有逻辑错误，但是一直报错无法运行，可以尝试修改为非严格模式，看是否能运行

set hive.mapred.mode=nonstrict;    --nonstrict，strict

with as 语句存储在本地，从而做到with…as语句只执行一次，来提高效率

对应喜欢用 with as 形式查询的话，可以设置一下这个，来提升效率

set hive.optimize.cte.materialize.threshold=1;

配置计算引擎

Hive底层的计算由分布式计算框架实现,目前支持三种计算引擎，分别是MapReduce、Tez、 Spark，默认为MapReduce

MapReduce引擎：多job串联，基于磁盘，落盘的地方比较多。虽然慢，但一定能跑出结果。一般处理，周、月、年指标。

Spark引擎：虽然在Shuffle过程中也落盘，但是并不是所有算子都需要Shuffle，尤其是多算子过程，中间过程不落盘 DAG有向无环图。兼顾了可靠性和效率。一般处理天指标。

Tez引擎：完全基于内存。注意：如果数据量特别大，慎重使用。容易OOM。一般用于快速出结果，数据量比较小的场景。

set hive.execution.engine=mr;    --mr、tez、spark

其他set设置

set hive.exec.parallel=true;    --开启任务并行执行 
set hive.exec.parallel.thread.number=8;   -- 同一个sql允许并行任务的最大线程数
set hive.exec.max.dynamic.partitions=1000           -- 在所有执行MR的节点上，最大一共可以创建多少个动态分区。
set hive.exec.max.dynamic.partitions.pernode=100   -- 在每个执行MR的节点上，最大可以创建多少个动态分区
set hive.auto.convert.join = false;    --取消小表加载至内存中
set hive.mapjoin.smalltable.filesize=25000000;   --设置小表大小

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 数据聚合成键值对时，根据值大小进行排序

Thu, 17 Nov 2022 00:00:00 GMT

背景

最近对用户的行为数据进行统计分析时，需要列出不同用户的具体详情，方便进行观察，在hive中虽然有排序函数，但是处理键值对数据时，不能根据值进行排序，需要巧妙借助中间过程来处理，总结出来与大家进行分享，也方便后面自己查找使用

预想效果

创建测试数据

--创建临时表
use test;
create table tmp_datashare
(id string comment '用户id',
click string comment '点击位置',
cnt int comment '点击次数')
COMMENT '用户点击行为统计'
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LINES TERMINATED BY '\n';

--加载数据
load data local inpath '/tmp/datashare.txt' overwrite into table tmp_datashare;

测试数据：

数据处理过程

数据处理具体步骤：

运用窗口函数进行降序排列增加一个添加辅助列

对数据进行拼接并补全数字，比如：id_1中 首页：20，降序序号：2，需要转换为 00002:首页:20

然后再进行分组聚合运用sort_array进行排序，并进行拼接

最后再进行替换

具体代码如下：

with a as (select id,click,cnt,
			row_number() over(partition by id order by cnt desc) as rn
		from tmp_datashare
			),
	b as (select id,click,cnt,
			concat(lpad(rn, 5, '0'), '#', click, ':',cnt) as click_cnt_temp_1
		from a
		),
	c as (select id,
			concat_ws(';',
				sort_array(collect_list(click_cnt_temp_1))
				) as click_cnt_temp_2
		from b
		group by id
		)
select id,regexp_replace(click_cnt_temp_2,'\\d+#','') as click_cnt
from c

结果数据：

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 中的常用函数

Thu, 11 Aug 2022 00:00:00 GMT

背景

现阶段各个公司的数据慢慢的增多，很多数据都是存放在基于Hadoop的集群上，数据的查询一般使用的是hive，很多公司的数据中台也是使用hive来进行数据处理，本篇文章就来分享下在hive中常用的函数

常用函数

set类设置

查询结果显示表头

set hive.cli.print.header=true;

设置Fetch抓取，不走job

set hive.fetch.task.conversion=more;

展示数据库

set hive.cli.print.current.db=true;

修改是否使用静默

set hive.compute.query.using.stats=false;

日期类函数

当天

select current_date()
运行结果：'2022-08-11'

当月第一天

select trunc(current_date(),'MM')      
运行结果：'2022-08-01'
select date_format(to_date(trunc(current_date(),'MM')),"yyyyMMdd") 
运行结果：'20220801'

当月最后一天

select last_day(current_date)  
运行结果：'2022-08-31'

上个月

select date_format(add_months(CURRENT_DATE,-1),'yyyyMM')
运行结果：'202207'

周几

select pmod(datediff(current_date(),'1900-01-08'),7)+1
运行结果：'4'

获取当前时间戳

select unix_timestamp()
运行结果：'1660212154'

字符串类函数

字符拼接

--concat（参数1,参数2,...参数n）
select concat('a','b','c')
运行结果：'abc'

select concat('a','b',null,'c')   --包含一个null的话，结果为null
运行结果：NULL

字符以分割符进行拼接

--concat_ws(分隔符,参数1,参数2,...参数n)
select concat_ws(',','a','b','c')
运行结果：'a,b,c'

select concat_ws(',','a',null,'c')   --会忽略null
运行结果：'a,c'

select concat_ws(',',null,null,null)  --返回空字符，而不是null
运行结果：''

窗口类函数

ROW_NUMBER() –从1开始，按照顺序，生成分组内记录的序列
RANK() 生成数据项在分组中的排名，排名相等会在名次中留下空位
DENSE_RANK() 生成数据项在分组中的排名，排名相等会在名次中不会留下空位
LAG(col,n,DEFAULT) 用于统计窗口内往上第n行值第一个参数为列名，第二个参数为往上第n行（可选，默认为1），第三个参数为默认值（当往上第n行为NULL时候，取默认值，如不指定，则为NULL）
LEAD(col,n,DEFAULT) 用于统计窗口内往下第n行值第一个参数为列名，第二个参数为往下第n行（可选，默认为1），第三个参数为默认值（当往下第n行为NULL时候，取默认值，如不指定，则为NULL）

更多窗口函数可参考

《Hive分析函数系列文章》： http://lxw1234.com/archives/2015/07/367.htm

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 中一个好用的地址解析工具cpca（chinese_province_city_area_mapper）

Wed, 16 Feb 2022 00:00:00 GMT

简介

gihub地址： https://github.com/DQinYuan/chinese_province_city_area_mapper

cpca---chinese province city area，一个用于提取简体中文字符串中省，市和区并能够进行映射，检验和简单绘图的python模块

["徐汇区虹漕路461号58号楼5楼", "泉州市洛江区万安塘西工业区"] ↓ 

省市区地址

上海市上海市徐汇区虹漕路461号58号楼5楼

福建省泉州市洛江区万安塘西工业区

“地址”列：代表去除了省市区之后的具体地址

省	市	区	地址
上海市	上海市	徐汇区	虹漕路461号58号楼5楼
福建省	泉州市	洛江区	万安塘西工业区

安装介绍

该库目前仅支持Python3，在命令行直接进行安装即可： pip install cpca

windows 中需要C/C++编译环境的支持，需要下载另外的软件，然后再进行安装 http://go.microsoft.com/fwlink/?LinkId=691126

编译环境的安装教程： https://o7planning.org/11467/install-microsoft-visual-cpp-build-tools

基本使用方法

常规用法

会自动补全相应的省、市、区

import cpca

location_str = ["徐汇区虹漕路461号58号楼5楼", 
                "泉州市洛江区万安塘西工业区", 
                "北京朝阳区北苑华贸城"]

data=cpca.transform(location_str)

data

l=['灵宝市函谷关镇']

df = cpca.transform(l)
df

df.loc[0,"市"]

重名情况

中国的区级行政单位非常的多，经常有重名的情况，比如“北京市朝阳区”和“吉林省长春市朝阳区”，当有上级地址信息的时候，cpca 能够根据上级地址推断出这是哪个区，但是如果没有上级地址信息，单纯只有一个区名的时候， cpca 就没法推断了，只能随便选一个了，通过 umap 参数你可以指定这种情况下该选择哪一个

从例子可以看出，umap 字典的 key 是区名，value 是区的 adcode，这里 110105 就是北京市朝阳区的 adcode，具体的 adcode 可以去全国行政区划查询平台上查询

全国行政区划查询平台： http://xzqh.mca.gov.cn/map

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

SecureCRT 利用Python脚本自动登陆服务器，自动验证Google-Authenticator动态验证码

Tue, 18 Jan 2022 00:00:00 GMT

背景

本地连接远端的服务器，SecureCRT可以说是一大利器，可以保存密码、设置自动登陆等，每次都可以一键直连服务器

最近因公司加强了服务器登陆验证，增加了二次认证，必须用Google Authenticator输入6位动态验证码，才能成功登陆，这样的话每次都得打开手机，手动输入验证码比较麻烦

在 Python 中有这样的库 pyotp 可以直接生成Google Authenticator输入6位动态验证码，前提是你知道谷歌验证码对应的密钥，一般是在最开始让扫描二维的下方会提示出来

SecureCRT支持利用一些语言脚本来实现自动登陆，比如：python、vbs，本篇文章来介绍如何利用 python 脚本自动登陆

SecureCRT版本

电脑为Win10操作系统

SecureCRT版本：Version 6.7.0 (build 153)

SecureCRT中的python版本：python2.6 （可以在安装文件里面查看到）

由于没有更新SecureCRT版本，一直用的老版本，支持的python也算是比较老了！！！

最新的SecureCRT版本是支持python3，但是需要进行一些设置，相对比较麻烦，感兴趣的话可以看看这篇文章：

《How-To: Use Python 3.8 with SecureCRT v9.0 for Windows》

https://forums.vandyke.com/showthread.php?t=14295

遇到问题

参考网上分享的一些例子，在 import pyotp 时总是会报错

《python 实现 jumpserver 自动登录》 https://mp.weixin.qq.com/s/aLazW8WUVfvsICnHXes3CA

即使添加了python包路径也不行，一直报错，pyotp 是兼容python2、python3所有版本

解决方法

通过提示可以看出，import sys 时并没有报错，说明python内置的包，是可以直接导入使用的，经过测试把 pyotp 源码中涉及到生成动态码的库import时，没有报错，说明已经走通了

这时就需要剖析 pyotp 源码，有哪些是生成生成动态码必须的，把冗余的代码全部剔除即可，经过分析也就是两个类有用，如下所示：

class OTP(object):
    def __init__(self, s, digits=6, digest= hashlib.sha1, name= None,issuer= None):
        self.digits = digits
        self.digest = digest
        self.secret = s
        self.name = name or 'Secret'
        self.issuer = issuer
        
    def generate_otp(self, input):
        if input < 0:
            raise ValueError('input must be positive integer')
        hasher = hmac.new(self.byte_secret(), self.int_to_bytestring(input), self.digest)
        hmac_hash = bytearray(hasher.digest())
        offset = hmac_hash[-1] & 0xf
        code = ((hmac_hash[offset] & 0x7f) << 24 |
                (hmac_hash[offset + 1] & 0xff) << 16 |
                (hmac_hash[offset + 2] & 0xff) << 8 |
                (hmac_hash[offset + 3] & 0xff))
        str_code = str(code % 10 ** self.digits)
        while len(str_code) < self.digits:
            str_code = '0' + str_code

        return str_code

    def byte_secret(self):
        secret = self.secret
        missing_padding = len(secret) % 8
        if missing_padding != 0:
            secret += '=' * (8 - missing_padding)
        return base64.b32decode(secret, casefold=True)

    @staticmethod
    def int_to_bytestring(i, padding= 8):
        result = bytearray()
        while i != 0:
            result.append(i & 0xFF)
            i >>= 8
        # It's necessary to convert the final result from bytearray to bytes
        # because the hmac functions in python 2.6 and 3.3 don't work with
        # bytearray
        return bytes(bytearray(reversed(result)).rjust(padding, b'\0'))
        
        
class TOTP(OTP):
    def __init__(self, s, digits= 6, digest=hashlib.sha1, name=None,issuer=None, interval= 30):
        self.interval = interval
        super(TOTP,self).__init__(s=s, digits=digits, digest=digest, name=name, issuer=issuer)

    def now(self):
        return self.generate_otp(self.timecode(datetime.datetime.now()))

    def timecode(self, for_time):
        if for_time.tzinfo:
            return int(calendar.timegm(for_time.utctimetuple()) / self.interval)
        else:
            return int(time.mktime(for_time.timetuple()) / self.interval)

完整代码

以下为SecureCRT利用Python脚本自动登陆服务器的完整代码：

# $language = "Python"
# $interface = "1.0"

import calendar
import datetime
import hashlib
import time
import base64
import hmac

class OTP(object):
    def __init__(self, s, digits=6, digest= hashlib.sha1, name= None,issuer= None):
        self.digits = digits
        self.digest = digest
        self.secret = s
        self.name = name or 'Secret'
        self.issuer = issuer
        
    def generate_otp(self, input):
        if input < 0:
            raise ValueError('input must be positive integer')
        hasher = hmac.new(self.byte_secret(), self.int_to_bytestring(input), self.digest)
        hmac_hash = bytearray(hasher.digest())
        offset = hmac_hash[-1] & 0xf
        code = ((hmac_hash[offset] & 0x7f) << 24 |
                (hmac_hash[offset + 1] & 0xff) << 16 |
                (hmac_hash[offset + 2] & 0xff) << 8 |
                (hmac_hash[offset + 3] & 0xff))
        str_code = str(code % 10 ** self.digits)
        while len(str_code) < self.digits:
            str_code = '0' + str_code

        return str_code

    def byte_secret(self):
        secret = self.secret
        missing_padding = len(secret) % 8
        if missing_padding != 0:
            secret += '=' * (8 - missing_padding)
        return base64.b32decode(secret, casefold=True)

    @staticmethod
    def int_to_bytestring(i, padding= 8):
        result = bytearray()
        while i != 0:
            result.append(i & 0xFF)
            i >>= 8
        # It's necessary to convert the final result from bytearray to bytes
        # because the hmac functions in python 2.6 and 3.3 don't work with
        # bytearray
        return bytes(bytearray(reversed(result)).rjust(padding, b'\0'))
        
        
class TOTP(OTP):
    def __init__(self, s, digits= 6, digest=hashlib.sha1, name=None,issuer=None, interval= 30):
        self.interval = interval
        super(TOTP,self).__init__(s=s, digits=digits, digest=digest, name=name, issuer=issuer)

    def now(self):
        return self.generate_otp(self.timecode(datetime.datetime.now()))

    def timecode(self, for_time):
        if for_time.tzinfo:
            return int(calendar.timegm(for_time.utctimetuple()) / self.interval)
        else:
            return int(time.mktime(for_time.timetuple()) / self.interval)

username='aaa'
password='aaa'
google_author_secret_key='自己的密钥'

def Main():
    tab = crt.GetScriptTab()
    if tab.Session.Connected != True:
        crt.Dialog.MessageBox("Session Not Connected")
        return
    tab.Screen.Synchronous = True
    
   
    tab.Screen.WaitForStrings(['Password: '])
    tab.Screen.Send(password+'\r\n')
    tab.Screen.WaitForStrings(['Please enter 6 digits.[MFA auth]: '])
    vc = TOTP(google_author_secret_key).now()
    tab.Screen.Send("{vc}\r\n".format(vc=vc))
    
    return


Main()

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

数据分析师常用的-Linux-命令总结

Fri, 05 Nov 2021 00:00:00 GMT

背景

也许你有这样的疑问，数据分析师为什么要了解Linux？这不是开发人员应该了解的吗？把Windows+SQL+Excel+Python玩的精通，不香吗？

以上的疑问也许处有人会提出，但随着个人的职业成长，企业数字化的发展，终究会与Linux系统打交道，比如：在数据挖掘时，大量的数据需要做分析、特征提取，然后跑模型，这些任务在个人的Windows系统基本完全做不了，只能在Linux服务器上来完成

备注：在大厂就职的同学 and 公司基建做的非常好的，可以忽略本文，说明你们公司比本小编曾经就职的某手好点，当然多学习一些知识，对自己百利而无一害，活到老学到老

以下介绍的命令是基于： Centos系统，Linux的一个发行版

常用命令

pwd

当前所处的文件夹位置

ls

列出当前文件夹里面的文件及子文件夹

ll

该命令相当于 ls -l

展示文件夹里面的文件及子文件夹详细信息，有点类似在Windows里面查看文件夹时以详细信息方式展示一样

cd

切换目录，换到别的文件夹

mkdir

创建一个新建文件夹

cp

cp 文件新文件夹

复制文件到新的文件夹里面，copy的简写

cp -r 文件夹新文件夹

复制整个文件夹到新的文件夹里面，需要添加 -r 参数，进行递归式复制

mv

mv 文件新文件夹

移动文件到新文件夹，move 的简写

mv 文件夹新文件夹

移动文件夹到新文件夹

cat

cat 文件名

展示文件里面的内容

sort

sort 文件名

对文件里面的行进行排序

sort -u 文件名

对文件里面的行进行去重并且排序，-u 是 unique 的简写

head

显示文件的前几行内容，在默认情况下，head命令显示文件的头10行内容，-n 参数可以指定要显示的行数

tail

显示文件的后几行内容，在默认情况下，tail显示最后 10 行，-n 参数可以指定要显示的行数

top

实时动态显示各进程的情况，可以按 M与T 进行可视化变化，可以显示为进度条样式

df -h

显示目前在 Linux 系统上的文件系统使用情况统计磁盘，-h 参数代表使用人类可读的格式 human-readable，是human的简写

ps -ef

查看服务器上所有运行的进程，类似Windows的查看任务管理器,PID 代表进程号

kill -9 进程号

强制杀死进程，类似Windows的在任务管理器中结束某个进程任务，用上面的 ps 命令查出进程号后，可以直接强制退出该进程

rm

删除文件或者文件夹，谨慎使用，删除掉就不容易恢复，不像Windows在回收站可以找回

rm 文件名

删除文件

rm -r 文件夹 删除文夹，-r 参数为递归删除文件夹及子文件夹里面的文件

好用的学习网站

以上介绍的只是几个常用的命令，下面列出几个网站，个人感觉这几个比较好用，供大家可参考学习

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive 中各种日期格式转换方法总结

Fri, 22 Oct 2021 00:00:00 GMT

背景

日期计算平时在业务取数时经常涉及到，但是数据库中经常存放着不同的日期格式，有的存放是时间戳、有的是字符串等，这时需要对其进行转换才能提取到准确的数据，这里介绍的均是hive里面的函数功能，以下内容均是业务的数据需求经常使用的部分

时间戳

unix时间戳是从1970年1月1日（UTC/GMT的午夜）开始所经过的秒数，不考虑闰秒，一般为10位的整数

一个在线工具：https://tool.lu/timestamp/

字符串日期

如：'2021-10-21 19:25:50'，'2021-10-21 20:25:50.0'，'2021-10-21 20:25'

日期格式转换

时间戳--->正常的日期格式

获取当前时间戳

select unix_timestamp()

把时间戳转为正常的日期

select from_unixtime(unix_timestamp(),'yyyy-MM-dd hh:mm:ss') as dt

业务中有时存放的是包含毫秒的整数，需要先转换为秒

select from_unixtime(cast(create_time/1000 as bigint),'yyyyMMdd') as dt

字符串日期

假如数据库存放的是格式为："yyyy-MM-dd hh:mm:ss"

截取日期部分

select substr('2021-10-22 17:34:56',1,10)
2021-10-22

字符串强制转换，获取日期

select to_date('2021-10-22 17:34:56')
2021-10-22

也可以通过date_format实现

select date_format('2021-10-22 17:34:56','yyyy-MM-dd')
2021-10-22

系统当前日期

当前日期

select current_date();
2021-10-22

字符串日期与系统当前日期比较，这个在业务中经常有用到

select substr('2021-10-22 17:34:56',1,10)>current_date()
false

前一日/昨日

select date_sub(current_date(),1);
2021-10-21

前一日12点/昨日12点

在业务中与截取的字符串日期进行比较时用

select concat(date_format(date_sub(current_date(),1),'yyyy-MM-dd'),' ','12');
2021-10-21 12

最近一个月/30天

select date_sub(current_date(),30);
2021-09-22

当月第一天

业务中经常用在滚动计算当月每日的业绩数据

select date_format(to_date(trunc(current_date(),'MM')),"yyyy-MM-dd");
2021-10-01

日期格式转换 yyyyMMdd--->yyyy-MM-dd

select from_unixtime(unix_timestamp('20211022','yyyyMMdd'),"yyyy-MM-dd");
2021-10-22

两个日期相隔天数

select datediff('2021-10-22', '2021-10-01');
21

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Hive HQL支持的2种查询语句风格，你喜欢哪一种？

Fri, 27 Aug 2021 00:00:00 GMT

背景

在平时业务运营分析中经常会提取数据，也就是大家俗称的Sql Boy，表哥表姐，各大公司数据中台现在大部分用的都是基于Hadoop的分布式系统基础架构，用的比较多的有Hive数据仓库工具，数据分析师在数据查询时用的就是HQL，语法与Mysql有所不同，基本每天都会写大量的HQL语句，但你有试过哪些风格的写法呢？哪种风格的查询语句更容易理解呢？可能不同的人有不同的看法，下面展示具体的风格代码样式，看看你喜欢哪种

Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。Hadoop实现了一个分布式文件系统（ Distributed File System），其中一个组件是HDFS（Hadoop Distributed File System）

hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，这是一种可以存储、查询和分析存储在Hadoop中的大规模数据的机制。hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成MapReduce任务来执行。

风格一

这种风格大家都比较常用，从结果向源头倒着推，直接多层嵌套，一层一层往里面写，业务逻辑复杂的话有可能写很多层，达到几百行之多，目前很多公司在有数仓的支持下，基本嵌套的层数会比较少

select *
from
(
	(select *
	from a_temp
	where xxxx
    group by xxxx) as a
	left join 
	(select *
	from b_temp
	where xxxx) as b 
	on a.id=b.id
) temp
where xxxx
group by xxxx
order by xxxx

风格二

这种风格是利用 with 语句，从源头向结果正向推，可以把 with 语句理解为建立了一个临时视图/表一样，后面的表引用前面的表，逻辑是正向推进

with a as(select *
		from a_temp
		where xxxx 
		group by xxxx),
	 b as(select *
		from b_temp
		where xxxx)
select *
from a left join b on a.id=b.id
where xxxx 
group by xxxx
order by xxxx

两种风格的区别

风格一：用的最多，从结果向源头倒着推
风格二：容易理解，从源头向结果正向推

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

Python 基于ssh连接远程Mysql数据库

Fri, 20 Nov 2020 00:00:00 GMT

背景

如果需要访问远程服务器的Mysql数据库，但是该Mysql数据库为了安全期间，安全措施设置为只允许本地连接（也就是你需要登录到该台服务器才能使用），其他远程连接是不可以直接访问，并且相应的端口也做了修改，那么就需要基于ssh来连接该数据库。这种方式连接数据库与Navicat里面界面化基于ssh连接一样。

安装支持库

如果要连接Mysql，首先需要安装pymysql

pip install pymysql

安装基于ssh的库sshtunnel

pip install sshtunnel    #当前最新 0.3.1版

建议安装最新的sshtunnel库，旧版本库有一些bug

连接Mysql

基于ssh连接Mysql可以查看sshtunnel的文档，里面有一些案例

with SSHTunnelForwarder(
        ('192.168.1.1', 2222),
        ssh_password='123456',
        ssh_username='root',
        remote_bind_address=('127.0.0.1', 3306)) as server:
    print('SSH连接成功')
    conn = pymysql.connect(host='127.0.0.1',
                           port=server.local_bind_port,
                           user='root',
                           database='data',
                           charset='utf8')
    print('mysql数据库连接成功')
    cursor = conn.cursor()
    ...  #获取数据操作，此处省略
    cursor.close()
    conn.close()

自定义查询函数

可以对上面的连接进行封装为一个函数，方便其他地方使用

def mysql_ssh(sql,args=None):
    with SSHTunnelForwarder(
            ('192.168.1.1', 2222),
            ssh_password='123456',
            ssh_username='root',
            remote_bind_address=('127.0.0.1', 3306)) as server:
        print('SSH连接成功')
        conn = pymysql.connect(host='127.0.0.1',
                               port=server.local_bind_port,
                               user='root',
                               database='data',
                               charset='utf8')
        print('mysql数据库连接成功')
        cursor = conn.cursor()
        print('游标获取成功')
        try:
            print(f'执行查询语句：{sql}  参数：{args}')
            cursor.execute(sql,args)
            print('数据查询成功')
            conn.commit()
            print('事务提交成功')
            datas = cursor.fetchall()
            success = True
        except:
            print('数据查询失败')
            datas = None
            success = False

        print('正在关闭数据库连接')
        cursor.close()
        conn.close()

    return datas, success

注意点：

在使用数据库时，conn.commit()、cursor.close()、conn.close() 这些一定要规范使用，防止不必要的bug
传入参数时建议用这种方式cursor.execute(sql,args)，防止sql注入的风险

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注 DataShare （同微），不定期分享干货

Linux之NTFS、FAT32、exFAT-各种格式硬盘挂载整理

Wed, 11 Nov 2020 00:00:00 GMT

背景

由于业务需要频繁处理大量视频（几十GB），通过公司内网传输太慢，于是就每次处理视频时需要在服务器挂载硬盘或U盘。业务人员给的硬盘或U盘格式有时不一样，目前遇到的格式：NTFS、FAT32、exFAT，这几种格式大家在Windows上基本很常见，于是总结了这些格式的硬盘如何有效挂载到Linux服务器，分享出来供大家参考

NTFS挂载
FAT32挂载
exFAT挂载

NTFS挂载

第一步：安装驱动ntfs-3g

yum install ntfs-3g

第二步：查看硬盘信息（硬盘已通过USB插入服务器）

fdisk -l

会在最后列出该硬盘的信息，一般是sdb，默认只有1个分区，下面挂载时用的是sdb1

但有的硬盘里面也有2个分区的，如下所示：

Disk identifier: 9B602E4F-E563-4A27-9510-46DEBC0BAA20
#         Start          End    Size  Type            Name
 1           40       409639    200M  EFI System      EFI System Partition
 2       409640   3906961407    1.8T  Microsoft basic My Passport

如果是这种情况，下面挂载时就需要用到sdb2

第三步：挂载硬盘

cd /mnt
mkdir Windows   #挂载时一定要提前创建好该文件夹
mount -t ntfs-3g /dev/sdb1  /mnt/Windows

第四步：解除挂载

umount /dev/sdb1

硬盘挂载基本就以上这四步，下面主要列出其他格式硬盘挂载的重点步骤

FAT32挂载

不需要驱动，可以直接挂载

下面的挂载命令支持 中文、挂载后不同用户可读写权限，具体参数含义可自行百度查询

第三步：挂载硬盘

mount -t vfat -o iocharset=utf8,umask=000,rw,exec /dev/sdb1 /mnt/Windows

exFAT挂载

第一步：安装驱动fuse-exfat、exfat-utils

yum install fuse-exfat
yum install exfat-utils

第三步：挂载硬盘

mount /dev/sdb2  /mnt/Windows

总结

有的格式需要安装驱动，有的不需要
硬盘里面具体要看有几个分区，挂载时指定分区号 sdb1 or sdb2

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注DataShare，不定期分享干货

Python文件打包成exe可执行程序

Mon, 19 Oct 2020 00:00:00 GMT

背景

有时写的Python程序需要交给业务人员使用，但业务人员电脑上基本都没有安装Python，并且业务人员也不会使用命令行，所以就需要把Python程序打包成exe可执行程序，让业务人员无需安装Python，可以直接使用。

这里只针对Windows操作系统的打包，以及只针对业务人员使用场景。（Linux系统基本都是技术开发人员在使用，基本都用的是命令行；而Mac系统不知是否有相关的打包库，可以打包为dmg）

打包过程（以下均为在cmd命令行执行）

首先安装第三方库：pyinstaller

pip install pyinstaller

打包 需要先切换到打包程序目录， cd c:\xxx\xxx 然后对Python程序进行打包

pyinstaller -F xxx.py

结果 如果打包成功，当前目录下会增加一个新的dist文件夹，打开该文件夹，会发现打包好的exe文件：xxx.exe，文件名与Python程序文件相同
其他 打包大概流程如上所示，除此之外pyinstaller支持其他一些功能，比如打包时指定自定义图标，首先需要下载一张正常的ico，不能用直接修改后缀的，然后进行打包，一定是先图标文件路径，再是程序路径，如下所示：

pyinstaller -F  -i xxx.ico xxx.py

注意事项！！！

运行报错 虽然经过一番折腾，终于打包好exe可执行程序，但是双击运行时总是报错，无法成功运行，这种情况大多数是因为缺少第三方库造成的。

解决方法： 在打包之前先在cmd运行一次Python程序看是否成功运行

python xxx.py

如果能成功运行，那么打包后基本没什么问题
如果运行失败，那么查看报错信息，是否缺少第三方库，然后进行pip安装，确保能成功运行

文件太大 以上打包过程是不是很简单，但是有没有注意打包的exe文件有时会很大，有时几百兆大小，但是自己的Python程序也就几KB，这个问题也是自己之前遇到的难题（使用的是Anaconda），即使另外建立了新的环境也不行（conda create -n 环境名）

解决方法： 一定要使用Python官网下载的原生Python程序，并且确保系统环境变量里面只有这一个Python路径，只有这一个Python路径，只有这一个Python路径！！！

亲测自己的打包程序从200M降到50M大小

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号DataShare，不定期分享干货

NumPy论文都已经登上了Nature，Pythoneer会用了吗？

Fri, 25 Sep 2020 00:00:00 GMT

背景

NumPy（Numerical Python）诞生已经过去了 15 年，前一段时间NumPy 核心开发团队的论文终于发表，详细介绍了使用 NumPy 的数组编程（Array programming），并且登上了Nature 。

NumPy 是什么？它是大名鼎鼎的使用 Python 进行科学计算的基础软件包，是 Python 生态系统中数据分析、机器学习、科学计算的主力军，极大简化了向量与矩阵的操作处理。

功能强大的 N 维数组对象

精密广播功能函数

集成 C/C++ 和 Fortran 代码的工具

强大的线性代数、傅立叶变换和随机数功能

在平时数据处理中，大部分人用的都是Pandas，用Numpy的场景可能比较少，但是Pandas是基于Numpy实现的更高级的库，使大家用起来更方便。但在做深度学习时用Numpy比较多，比如：图像处理，图片里面其实都是Numpy数组；音频处理；文本处理等等。

下面为大家介绍一些Numpy的常用基础

Numpy基础

安装 由于Numpy是第三方库，默认是不集成在Python里面，所以就需要手动安装一下：如果你安装的是Anaconda，那么就不用再安装了，请忽略如果你是从官方网站下载的Python，那么你就需要手动安装一下这个库

#指定阿里云镜像，安装更快
pip install numpy -i https://mirrors.aliyun.com/pypi/simple/

导入 默认成规，numpy导入后命名为 np，所以在python脚本（程序）里面看见np一般都是代表numpy

import numpy as np

认识Ndarray 计算机里面能计算的就是数字，也就是数学里面的各种数字，我们都知道数学里面的数组可以有多层，也就是多维，1维就是向量，2维就是矩阵，3维就是$x y z$坐标轴构成的空间（形象理解），但体现在numpy中就是N 维数组对象 ndarray，它是一系列同类型数据的集合。

1维：

>>> import numpy as np
>>> a=np.array([1,2,3,4])
>>> print(a)
[1 2 3 4]
>>> type(a)
<class 'numpy.ndarray'>
>>> a.ndim
1

2维：

>>> import numpy as np
>>> b=np.array([[1,2,3],[4,5,6]])
>>> print(b)
[[1 2 3]
 [4 5 6]]
>>> type(b)
<class 'numpy.ndarray'>
>>> b.ndim
2

切片和索引 切片、索引与python内置的列表、字符串的切片和索引基本一样，如果理解了列表的切片和索引，那么ndarray对象就不在话下

>>> import numpy as np
>>> a=np.arange(10)
>>> print(a)
[0 1 2 3 4 5 6 7 8 9]
>>> type(a)
<class 'numpy.ndarray'>
>>> a.ndim
1
>>> a[:5]
array([0, 1, 2, 3, 4])
>>> a[7:]
array([7, 8, 9])
>>> a[3:6]
array([3, 4, 5])
>>> a[::2]
array([0, 2, 4, 6, 8])
>>> a[::-1]
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

>>> a[0]
0
>>> a[5]
5

数组操作

修改数组形状

>>> import numpy as np
>>> a=np.arange(10)
>>> print(a)
[0 1 2 3 4 5 6 7 8 9]
>>> type(a)
<class 'numpy.ndarray'>
>>> a.ndim
1
>>> b=a.reshape(5,2)
>>> print(b)
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
>>> b.ndim
2
>>> c=a.reshape(2,5)
>>> print(c)
[[0 1 2 3 4]
 [5 6 7 8 9]]
>>> c.ndim
2

数组转置

>>> import numpy as np
>>> a=np.arange(12).reshape(3,4)
>>> print(a)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
>>> np.transpose(a)
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
>>> a.T
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

数组连接 concatenate、stack、hstack、vstack这个几个函数均是数组连接，原理基本都一样，只要理解了其中一个，其他的都很好理解，这里只介绍concatenate

>>> import numpy as np
>>> a=np.array([[1,2],[3,4]]
... )
>>> b=np.array([[5,6],[7,8]])
>>> np.con
np.concatenate( np.conj(        np.conjugate(   np.convolve(
>>> np.concatenate([a,b],axis=0)   #沿着0轴拼接
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])
>>> np.concatenate([a,b],axis=1)   #沿着1轴拼接
array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

修改数组维度

>>> import numpy as np
>>> x=np.array([1,2])
>>> np.expand_dims(x,axis=0)
array([[1, 2]])
>>> np.expand_dims(x,axis=1)
array([[1],
       [2]])
>>> y=np.array([[1,2]])
>>> np.squeeze(y)    #从给定数组的形状中删除一维，当前维必须等于1
array([1, 2])

数组计算

>>> import numpy as np
>>> a1=np.array([1,2,3,4])
>>> a2=np.array([5,5,5,5])
>>> a1+a2
array([6, 7, 8, 9])
>>> np.add(a1,a2)
array([6, 7, 8, 9])
>>> a1-a2
array([-4, -3, -2, -1])
>>> np.subtract(a1,a2)
array([-4, -3, -2, -1])
>>> a1*a2
array([ 5, 10, 15, 20])
>>> np.multiply(a1,a2)
array([ 5, 10, 15, 20])
>>> a1/a2
array([0.2, 0.4, 0.6, 0.8])
>>> np.divide(a1,a2)
array([0.2, 0.4, 0.6, 0.8])

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号DataShare，不定期分享干货

Python math模块详解

Sun, 30 Aug 2020 00:00:00 GMT

概述

math模块是内置模块，提供了许多对浮点数的数学运算函数，提供类似C语言标准定义的数学函数（This module provides access to the mathematical functions defined by the C standard）

包含以下 七部分 函数：

算术函数（Number-theoretic and representation functions）
幂函数与对数函数（Power and logarithmic functions）
三角函数（Trigonometric functions）
角度转换函数（Angular conversion）
双曲函数（Hyperbolic functions）
特殊函数（Special functions）
常量（Constants）

math模块常用函数

虽然math模块提供的函数很多，但是现阶段工作中使用的很少，下面就列出一些实际工作中常用的函数：

注意：虽然math是内置模块，但使用前需要先import导入该库

import math

math.ceil(x)----------向上取整

>>> math.ceil(2.1)
3
>>> math.ceil(3.7)
4
>>> math.ceil(-1.5)
-1
>>> math.ceil(-3.1)
-3

math.floor(x)----------向下取整

>>> math.floor(1.2)
1
>>> math.floor(4.8)
4
>>> math.floor(-0.1)
-1
>>> math.floor(-2.8)
-3

math.exp(x)----------e的x次方，其中 e = 2.718281… 是自然对数的基数

>>> math.exp(1)
2.718281828459045
>>> math.exp(2)
7.38905609893065
>>> math.exp(0)
1.0

math.log(x,base=e)---------- 默认返回x 的自然对数,默认底为 e，如果指定底，返回指定底的对数

>>> math.log(math.exp(1))
1.0
>>> math.log(math.exp(0))
0.0
>>> math.log(math.exp(2))
2.0
>>> math.log(4,base=2)
2.0
>>> math.log(9,base=3)
2.0
>>> math.log(100,base=10)
2.0

math.pow(x, y)---------- x 的 y 次幂

>>> math.pow(2,3)
8.0
>>> math.pow(4,2)
16.0
>>> math.pow(-5,2)
25.0

math.sqrt(x)---------- x 的算术平方根，也就是正数的平方根

>>> math.sqrt(25)
5.0
>>> math.sqrt(4)
2.0
>>> math.sqrt(10)
3.1622776601683795

math.pi---------- 常量π，15位小数

>>> math.pi
3.141592653589793

math.e---------- 常量e，15位小数

>>> math.e
2.718281828459045

math.sin(x)---------- x弧度的正弦值

>>> math.sin(math.pi/2)
1.0
>>> math.sin(math.pi/3)
0.8660254037844386
>>> math.sin(math.pi/6)    #近似0.5
0.49999999999999994
>>> math.sin(math.pi/4)
0.7071067811865476

math.cos(x)---------- x弧度的余弦值

>>> math.cos(0)
1.0
>>> math.cos(math.pi/3)    #近似0.5
0.5000000000000001
>>> math.cos(math.pi/4)  
0.7071067811865476

math.degrees(x)----------将角度 x 从弧度转换为度数

>>> math.degrees(math.pi)
180.0
>>> math.degrees(math.pi/2)
90.0
>>> math.degrees(math.pi/6)    #近似30
29.999999999999996

math.radians(x)----------将角度 x 从度数转换为弧度

>>> math.radians(90)
1.5707963267948966
>>> math.radians(180)
3.141592653589793
>>> math.radians(360)
6.283185307179586

度数、弧度概念可参考历史相关文章，有详细说明

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号，不定期分享干货

Linux（Centos-7）中-Anaconda环境管理，安装不同的版本Python包

Mon, 10 Aug 2020 00:00:00 GMT

硬件信息及操作系统信息

服务器：戴尔R740

显卡：英伟达 Tesla V100

操作系统：CentOS Linux release 7.8.2003 (Core)

Anaconda安装

从官网下载 Anaconda3-2020.02-Linux-x86_64.sh，运行后一步一步安装

参考： https://blog.csdn.net/Gary1_Liu/article/details/81297927

Anaconda环境管理

克隆环境

conda create --name newname --clone oldname

例如：conda create --name pytorch1.5 --clone base

创建环境

conda create -n 环境名 python=3.7

例如：conda create -n pytorch1.5 python=3.7

激活环境

conda activate 环境名

例如：conda activate pytorch1.5

退出环境

conda deactivate

对虚拟环境中安装额外的包

conda install -n your_env_name [package]

例如：conda install -n pytorch1.5 pytorch==1.5.0 torchvision==0.6.0 cudatoolkit=10.2 -c pytorch

经测试后发现，只要激活了虚拟环境后，用pip直接安装也可以，安装的包是直接在虚拟环境里面

例如：pip install torch==1.5.0 torchvision==0.6.0

删除环境内某个包

conda remove --name 环境名包名

例如：conda remove --name pytorch1.5 pytorch

查看当前存在哪些虚拟环境

conda env list

查看安装了哪些包

conda list

检查更新当前conda

conda update conda

删除虚拟环境

conda remove --name oldname --all

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号，不定期分享干货

Python内置的 os 模块常用函数、方法

Sat, 11 Jul 2020 00:00:00 GMT

前言

无论是在自己Windows、MacOS电脑，还是在Linux服务器，在操作文件时，多多少少都会涉及到文件的管理。 Python里面有个自带的 os 模块，专门是用来对文件、路径等进行管理的工具，下面列出一些自己在工作中常用的函数、方法，供大家参考学习。

路径的正确表示，三种都可以

由于\是转义的意思，所以路径都用\\表示，例如： 'C:\\Users\\abc\\Desktop'
如果想用单个\，可以在前面加个r，例如： r'C:\Users\abc\Desktop'
也可以用/来表示，例如： 'C:/Users/abc/Desktop'

点点们的介绍

./ 当前你所编辑的这个脚本所在目录 ../ 当前你所编辑的这个脚本所在目录的上一级目录

os 模块常用函数、方法

无需pip安装，可以直接导入

import os

获取当前工作路径 也就是你编写的这个脚本所在的文件夹位置

os.getcwd()    #C:\\Users\\abc\\Desktop\\Python\\python库

获取绝对路径

path='./111.xlsx'
os.path.abspath(path)    #C:\\Users\\abc\\Desktop\\Python\\python库\\111.xlsx

获取文件的完整路径里面的文件名字

a='C:\\Users\\abc\\Desktop\\Python\\python库\\111.xlsx'
os.path.basename(a)     #111.xlsx

获取文件的完整路径里面的路径

a='C:\\Users\\abc\\Desktop\\Python\\python库\\111.xlsx'
os.path.dirname(a)     #C:\\Users\\abc\\Desktop\\Python\\python库

判断是否存在相应的文件或文件夹

a='./111.xlsx'
b='C:\\Users\\abc\\Desktop\\Python\\python库\\111'
os.path.exists(a)    #True
os.path.exists(b)   #False

分隔文件的完整路径为：路径、文件名字 相对上面的方法，这样可以一次都获取到，但是也有缺点，os.path.split只识别/，不识别\\，因此在用该方法时，需要先进行替换

a='C:\\Users\\abc\\Desktop\\Python\\python库\\111.xlsx'
b,c=os.path.split(a.replace('\\','/'))
#b  C:/Users/abc/Desktop/Python/python库
#c  111.xlsx

删除存在的文件

a='./111.xlsx'
os.remove(a)    #无返回值，直接删除该文件

创建文件夹 建议用makedirs方法，这样即可以直接创建单级文件夹，有可以创建多层级文件夹

os.makedirs('./a')
os.makedirs('./1/2')

以上这些方法是在工作中经常使用的，如有新的路径的需求可以在其他一些网站进行查找

历史相关文章

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货

数据去重 VBA字典法

Mon, 18 Mar 2019 00:00:00 GMT

在Excel里面数据去重方法比较多，目前用的比较多的有：

1. 数据--筛选---高级筛选

2. 数据透视表

但以上这两种方法都有局限性，比如需要去重的区域是多列数据

下面介绍一种通过VBA编写宏程序来进行数据去重，可以去重多列数据

先把代码呈现出来，再进行解释：


Sub 字典方法()

    Dim rng As Range       '定义一个区域，用于接收需要去重的单元格区域

    Set rng = Application.InputBox("请指定去重区域", "数据源区域", , , , , , 8)     '可以是一列，也可以是多列

    If rng Is Nothing Then End         '如果没有选择区域，则退出，注：是End，不是End IF



    Dim arr    '定义一个数组，用于存储去重区域的值

    arr = rng.value



    Dim a

    On Error Resume Next         '这里需要忽略错误，后面添加重复键值会引发错误



    Dim dic As Object    

    Set dic = CreateObject("scripting.dictionary")            '引用字典对象



    For Each a In arr

        If Len(a) > 0 Then     

            dic.Add CStr(a), ""     '往字典里面添加键值

        End If

    Next a

    Err.Clear



    Set rng = Application.InputBox("请指定结果存放区域，单个单元格即可", "存放区域", , , , , , 8)



    If Err <> 0 Then End



    rng(1).Resize(dic.Count, 1) = WorksheetFunction.Transpose(dic.Keys)         '往单元格里面写入去重后的数据



End Sub

这里主要运用的字典的键值唯一性，如果向字典里面添加已经存在的键，则会引发错误，所以中间部分需要忽略错误

数组+字典在VBA里面可以提升程序运行效率，如想提升VBA程序运行效率，可多运用数组、字典

DataShare Blog

Python与Rust类型参数对比：从TypeVar到泛型T

一、相同的目标：占位符与泛化

二、语法演进：殊途同归

三、类型约束：继承（Inheritance） vs. 特征（Trait）

Python：基于继承或协议的上界约束

Rust：基于 Trait 的行为约束

四、型变（Variance）：显式声明 vs. 自动推导

Python：定义 TypeVar 时显式声明型变

Rust：编译器自动推导型变

五、运行时存在性：类型擦除 vs. 单态化

六、高级特性对照表

七、从 Python 到 Rust：学习路径建议

八、总结对比表

历史相关文章

Python 装饰器的灵活实现：带参数与不带参数

背景

小编环境

函数装饰器实现

实现原理

类装饰器实现

两种实现方式的比较

实际应用场景

最佳实践

总结

历史相关文章

polars学习-11-用户自定义函数

背景

小编运行环境

提供的 api 函数/接口/方法

示例数据

map_elements 用法

map_batches 用法

提升用户自定义函数性能

numpy 通用函数

通过 Numba 提升自定义函数性能

注意事项

组合多列

流式计算

返回数据类型

历史相关文章

Python 利用 uv “一键” 快速部署服务

背景

小编环境

拉取项目

uv 部署环境

本地基于 uv 项目构建

历史相关文章

《Python-编程从新手到高手》知识点

背景

小编环境

Python中的变量：名称和值

类属性与类方法

流

print 刷新

并发与并行

历史相关文章

Python 函数参数类型与使用规则详解

背景

小编环境

完整函数参数示例1

完整函数参数示例2

历史相关文章

Python 3.14 无GIL解释器性能测试：释放多核CPU的并行潜力

背景

名词解释

小编环境

测试结果图

安装python3.14无GIL解释器

测试代码

历史相关文章

Python 标准库之pathlib（二），路径操作

背景

小编环境

创建目录方法：Path.mkdir()

方法签名：

参数详解：

基础用法示例

示例 1: 创建单级目录

示例 2: 创建多级目录（使用 parents=True）

Python：定义 `TypeVar` 时显式声明型变

示例 2: 创建多级目录（使用 `parents=True`）

示例 3: 安全创建目录（使用 `exist_ok=True`）